bda248c94a4b70f2d476ab3fea39f6ebe09d1fe6
[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 /* === Functions that needs to be kept longer in deprecated lib than normal time period === */
35 /**
36  * Add an entry to the legacy log table.
37  *
38  * @deprecated since 2.7 use new events instead
39  *
40  * @param    int     $courseid  The course id
41  * @param    string  $module  The module name  e.g. forum, journal, resource, course, user etc
42  * @param    string  $action  'view', 'update', 'add' or 'delete', possibly followed by another word to clarify.
43  * @param    string  $url     The file and parameters used to see the results of the action
44  * @param    string  $info    Additional description information
45  * @param    int     $cm      The course_module->id if there is one
46  * @param    int|stdClass $user If log regards $user other than $USER
47  * @return void
48  */
49 function add_to_log($courseid, $module, $action, $url='', $info='', $cm=0, $user=0) {
50     debugging('add_to_log() has been deprecated, please rewrite your code to the new events API', DEBUG_DEVELOPER);
52     // This is a nasty hack that allows us to put all the legacy stuff into legacy storage,
53     // this way we may move all the legacy settings there too.
54     $manager = get_log_manager();
55     if (method_exists($manager, 'legacy_add_to_log')) {
56         $manager->legacy_add_to_log($courseid, $module, $action, $url, $info, $cm, $user);
57     }
58 }
60 /**
61  * Function to call all event handlers when triggering an event
62  *
63  * @deprecated since 2.6
64  *
65  * @param string $eventname name of the event
66  * @param mixed $eventdata event data object
67  * @return int number of failed events
68  */
69 function events_trigger($eventname, $eventdata) {
70     debugging('events_trigger() is deprecated, please use new events instead', DEBUG_DEVELOPER);
71     return events_trigger_legacy($eventname, $eventdata);
72 }
74 /**
75  * List all core subsystems and their location
76  *
77  * This is a whitelist of components that are part of the core and their
78  * language strings are defined in /lang/en/<<subsystem>>.php. If a given
79  * plugin is not listed here and it does not have proper plugintype prefix,
80  * then it is considered as course activity module.
81  *
82  * The location is optionally dirroot relative path. NULL means there is no special
83  * directory for this subsystem. If the location is set, the subsystem's
84  * renderer.php is expected to be there.
85  *
86  * @deprecated since 2.6, use core_component::get_core_subsystems()
87  *
88  * @param bool $fullpaths false means relative paths from dirroot, use true for performance reasons
89  * @return array of (string)name => (string|null)location
90  */
91 function get_core_subsystems($fullpaths = false) {
92     global $CFG;
94     // NOTE: do not add any other debugging here, keep forever.
96     $subsystems = core_component::get_core_subsystems();
98     if ($fullpaths) {
99         return $subsystems;
100     }
102     debugging('Short paths are deprecated when using get_core_subsystems(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
104     $dlength = strlen($CFG->dirroot);
106     foreach ($subsystems as $k => $v) {
107         if ($v === null) {
108             continue;
109         }
110         $subsystems[$k] = substr($v, $dlength+1);
111     }
113     return $subsystems;
116 /**
117  * Lists all plugin types.
118  *
119  * @deprecated since 2.6, use core_component::get_plugin_types()
120  *
121  * @param bool $fullpaths false means relative paths from dirroot
122  * @return array Array of strings - name=>location
123  */
124 function get_plugin_types($fullpaths = true) {
125     global $CFG;
127     // NOTE: do not add any other debugging here, keep forever.
129     $types = core_component::get_plugin_types();
131     if ($fullpaths) {
132         return $types;
133     }
135     debugging('Short paths are deprecated when using get_plugin_types(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER);
137     $dlength = strlen($CFG->dirroot);
139     foreach ($types as $k => $v) {
140         if ($k === 'theme') {
141             $types[$k] = 'theme';
142             continue;
143         }
144         $types[$k] = substr($v, $dlength+1);
145     }
147     return $types;
150 /**
151  * Use when listing real plugins of one type.
152  *
153  * @deprecated since 2.6, use core_component::get_plugin_list()
154  *
155  * @param string $plugintype type of plugin
156  * @return array name=>fulllocation pairs of plugins of given type
157  */
158 function get_plugin_list($plugintype) {
160     // NOTE: do not add any other debugging here, keep forever.
162     if ($plugintype === '') {
163         $plugintype = 'mod';
164     }
166     return core_component::get_plugin_list($plugintype);
169 /**
170  * Get a list of all the plugins of a given type that define a certain class
171  * in a certain file. The plugin component names and class names are returned.
172  *
173  * @deprecated since 2.6, use core_component::get_plugin_list_with_class()
174  *
175  * @param string $plugintype the type of plugin, e.g. 'mod' or 'report'.
176  * @param string $class the part of the name of the class after the
177  *      frankenstyle prefix. e.g 'thing' if you are looking for classes with
178  *      names like report_courselist_thing. If you are looking for classes with
179  *      the same name as the plugin name (e.g. qtype_multichoice) then pass ''.
180  * @param string $file the name of file within the plugin that defines the class.
181  * @return array with frankenstyle plugin names as keys (e.g. 'report_courselist', 'mod_forum')
182  *      and the class names as values (e.g. 'report_courselist_thing', 'qtype_multichoice').
183  */
184 function get_plugin_list_with_class($plugintype, $class, $file) {
186     // NOTE: do not add any other debugging here, keep forever.
188     return core_component::get_plugin_list_with_class($plugintype, $class, $file);
191 /**
192  * Returns the exact absolute path to plugin directory.
193  *
194  * @deprecated since 2.6, use core_component::get_plugin_directory()
195  *
196  * @param string $plugintype type of plugin
197  * @param string $name name of the plugin
198  * @return string full path to plugin directory; NULL if not found
199  */
200 function get_plugin_directory($plugintype, $name) {
202     // NOTE: do not add any other debugging here, keep forever.
204     if ($plugintype === '') {
205         $plugintype = 'mod';
206     }
208     return core_component::get_plugin_directory($plugintype, $name);
211 /**
212  * Normalize the component name using the "frankenstyle" names.
213  *
214  * @deprecated since 2.6, use core_component::normalize_component()
215  *
216  * @param string $component
217  * @return array as (string)$type => (string)$plugin
218  */
219 function normalize_component($component) {
221     // NOTE: do not add any other debugging here, keep forever.
223     return core_component::normalize_component($component);
226 /**
227  * Return exact absolute path to a plugin directory.
228  *
229  * @deprecated since 2.6, use core_component::normalize_component()
230  *
231  * @param string $component name such as 'moodle', 'mod_forum'
232  * @return string full path to component directory; NULL if not found
233  */
234 function get_component_directory($component) {
236     // NOTE: do not add any other debugging here, keep forever.
238     return core_component::get_component_directory($component);
241 /**
242  * Get the context instance as an object. This function will create the
243  * context instance if it does not exist yet.
244  *
245  * @deprecated since 2.2, use context_course::instance() or other relevant class instead
246  * @todo This will be deleted in Moodle 2.8, refer MDL-34472
247  * @param integer $contextlevel The context level, for example CONTEXT_COURSE, or CONTEXT_MODULE.
248  * @param integer $instance The instance id. For $level = CONTEXT_COURSE, this would be $course->id,
249  *      for $level = CONTEXT_MODULE, this would be $cm->id. And so on. Defaults to 0
250  * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
251  *      MUST_EXIST means throw exception if no record or multiple records found
252  * @return context The context object.
253  */
254 function get_context_instance($contextlevel, $instance = 0, $strictness = IGNORE_MISSING) {
256     debugging('get_context_instance() is deprecated, please use context_xxxx::instance() instead.', DEBUG_DEVELOPER);
258     $instances = (array)$instance;
259     $contexts = array();
261     $classname = context_helper::get_class_for_level($contextlevel);
263     // we do not load multiple contexts any more, PAGE should be responsible for any preloading
264     foreach ($instances as $inst) {
265         $contexts[$inst] = $classname::instance($inst, $strictness);
266     }
268     if (is_array($instance)) {
269         return $contexts;
270     } else {
271         return $contexts[$instance];
272     }
274 /* === End of long term deprecated api list === */
276 /**
277  * Adds a file upload to the log table so that clam can resolve the filename to the user later if necessary
278  *
279  * @deprecated since 2.7 - use new file picker instead
280  *
281  */
282 function clam_log_upload($newfilepath, $course=null, $nourl=false) {
283     throw new coding_exception('clam_log_upload() can not be used any more, please use file picker instead');
286 /**
287  * This function logs to error_log and to the log table that an infected file has been found and what's happened to it.
288  *
289  * @deprecated since 2.7 - use new file picker instead
290  *
291  */
292 function clam_log_infected($oldfilepath='', $newfilepath='', $userid=0) {
293     throw new coding_exception('clam_log_infected() can not be used any more, please use file picker instead');
296 /**
297  * Some of the modules allow moving attachments (glossary), in which case we need to hunt down an original log and change the path.
298  *
299  * @deprecated since 2.7 - use new file picker instead
300  *
301  */
302 function clam_change_log($oldpath, $newpath, $update=true) {
303     throw new coding_exception('clam_change_log() can not be used any more, please use file picker instead');
306 /**
307  * Replaces the given file with a string.
308  *
309  * @deprecated since 2.7 - infected files are now deleted in file picker
310  *
311  */
312 function clam_replace_infected_file($file) {
313     throw new coding_exception('clam_replace_infected_file() can not be used any more, please use file picker instead');
316 /**
317  * Deals with an infected file - either moves it to a quarantinedir
318  * (specified in CFG->quarantinedir) or deletes it.
319  *
320  * If moving it fails, it deletes it.
321  *
322  * @deprecated since 2.7
323  */
324 function clam_handle_infected_file($file, $userid=0, $basiconly=false) {
325     throw new coding_exception('clam_handle_infected_file() can not be used any more, please use file picker instead');
328 /**
329  * If $CFG->runclamonupload is set, we scan a given file. (called from {@link preprocess_files()})
330  *
331  * @deprecated since 2.7
332  */
333 function clam_scan_moodle_file(&$file, $course) {
334     throw new coding_exception('clam_scan_moodle_file() can not be used any more, please use file picker instead');
338 /**
339  * Checks whether the password compatibility library will work with the current
340  * version of PHP. This cannot be done using PHP version numbers since the fix
341  * has been backported to earlier versions in some distributions.
342  *
343  * See https://github.com/ircmaxell/password_compat/issues/10 for more details.
344  *
345  * @deprecated since 2.7 PHP 5.4.x should be always compatible.
346  *
347  */
348 function password_compat_not_supported() {
349     throw new coding_exception('Do not use password_compat_not_supported() - bcrypt is now always available');
352 /**
353  * Factory method that was returning moodle_session object.
354  *
355  * @deprecated since 2.6
356  */
357 function session_get_instance() {
358     throw new coding_exception('session_get_instance() is removed, use \core\session\manager instead');
361 /**
362  * Returns true if legacy session used.
363  *
364  * @deprecated since 2.6
365  */
366 function session_is_legacy() {
367     throw new coding_exception('session_is_legacy() is removed, do not use any more');
370 /**
371  * Terminates all sessions, auth hooks are not executed.
372  *
373  * @deprecated since 2.6
374  */
375 function session_kill_all() {
376     throw new coding_exception('session_kill_all() is removed, use \core\session\manager::kill_all_sessions() instead');
379 /**
380  * Mark session as accessed, prevents timeouts.
381  *
382  * @deprecated since 2.6
383  */
384 function session_touch($sid) {
385     throw new coding_exception('session_touch() is removed, use \core\session\manager::touch_session() instead');
388 /**
389  * Terminates one sessions, auth hooks are not executed.
390  *
391  * @deprecated since 2.6
392  */
393 function session_kill($sid) {
394     throw new coding_exception('session_kill() is removed, use \core\session\manager::kill_session() instead');
397 /**
398  * Terminates all sessions of one user, auth hooks are not executed.
399  *
400  * @deprecated since 2.6
401  */
402 function session_kill_user($userid) {
403     throw new coding_exception('session_kill_user() is removed, use \core\session\manager::kill_user_sessions() instead');
406 /**
407  * Setup $USER object - called during login, loginas, etc.
408  *
409  * Call sync_user_enrolments() manually after log-in, or log-in-as.
410  *
411  * @deprecated since 2.6
412  */
413 function session_set_user($user) {
414     throw new coding_exception('session_set_user() is removed, use \core\session\manager::set_user() instead');
417 /**
418  * Is current $USER logged-in-as somebody else?
419  * @deprecated since 2.6
420  */
421 function session_is_loggedinas() {
422     throw new coding_exception('session_is_loggedinas() is removed, use \core\session\manager::is_loggedinas() instead');
425 /**
426  * Returns the $USER object ignoring current login-as session
427  * @deprecated since 2.6
428  */
429 function session_get_realuser() {
430     throw new coding_exception('session_get_realuser() is removed, use \core\session\manager::get_realuser() instead');
433 /**
434  * Login as another user - no security checks here.
435  * @deprecated since 2.6
436  */
437 function session_loginas($userid, $context) {
438     throw new coding_exception('session_loginas() is removed, use \core\session\manager::loginas() instead');
441 /**
442  * Minify JavaScript files.
443  *
444  * @deprecated since 2.6
445  */
446 function js_minify($files) {
447     throw new coding_exception('js_minify() is removed, use core_minify::js_files() or core_minify::js() instead.');
450 /**
451  * Minify CSS files.
452  *
453  * @deprecated since 2.6
454  */
455 function css_minify_css($files) {
456     throw new coding_exception('css_minify_css() is removed, use core_minify::css_files() or core_minify::css() instead.');
459 // === Deprecated before 2.6.0 ===
461 /**
462  * Hack to find out the GD version by parsing phpinfo output
463  *
464  * @deprecated
465  */
466 function check_gd_version() {
467     throw new coding_exception('check_gd_version() is removed, GD extension is always available now');
470 /**
471  * Not used any more, the account lockout handling is now
472  * part of authenticate_user_login().
473  * @deprecated
474  */
475 function update_login_count() {
476     throw new coding_exception('update_login_count() is removed, all calls need to be removed');
479 /**
480  * Not used any more, replaced by proper account lockout.
481  * @deprecated
482  */
483 function reset_login_count() {
484     throw new coding_exception('reset_login_count() is removed, all calls need to be removed');
487 /**
488  * @deprecated
489  */
490 function update_log_display_entry($module, $action, $mtable, $field) {
492     throw new coding_exception('The update_log_display_entry() is removed, please use db/log.php description file instead.');
495 /**
496  * @deprecated use the text formatting in a standard way instead (http://docs.moodle.org/dev/Output_functions)
497  *             this was abused mostly for embedding of attachments
498  */
499 function filter_text($text, $courseid = NULL) {
500     throw new coding_exception('filter_text() can not be used anymore, use format_text(), format_string() etc instead.');
503 /**
504  * @deprecated use $PAGE->https_required() instead
505  */
506 function httpsrequired() {
507     throw new coding_exception('httpsrequired() can not be used any more use $PAGE->https_required() instead.');
510 /**
511  * Given a physical path to a file, returns the URL through which it can be reached in Moodle.
512  *
513  * @deprecated since 3.1 - replacement legacy file API methods can be found on the moodle_url class, for example:
514  * The moodle_url::make_legacyfile_url() method can be used to generate a legacy course file url. To generate
515  * course module file.php url the moodle_url::make_file_url() should be used.
516  *
517  * @param string $path Physical path to a file
518  * @param array $options associative array of GET variables to append to the URL
519  * @param string $type (questionfile|rssfile|httpscoursefile|coursefile)
520  * @return string URL to file
521  */
522 function get_file_url($path, $options=null, $type='coursefile') {
523     debugging('Function get_file_url() is deprecated, please use moodle_url factory methods instead.', DEBUG_DEVELOPER);
524     global $CFG;
526     $path = str_replace('//', '/', $path);
527     $path = trim($path, '/'); // no leading and trailing slashes
529     // type of file
530     switch ($type) {
531        case 'questionfile':
532             $url = $CFG->wwwroot."/question/exportfile.php";
533             break;
534        case 'rssfile':
535             $url = $CFG->wwwroot."/rss/file.php";
536             break;
537         case 'httpscoursefile':
538             $url = $CFG->httpswwwroot."/file.php";
539             break;
540          case 'coursefile':
541         default:
542             $url = $CFG->wwwroot."/file.php";
543     }
545     if ($CFG->slasharguments) {
546         $parts = explode('/', $path);
547         foreach ($parts as $key => $part) {
548         /// anchor dash character should not be encoded
549             $subparts = explode('#', $part);
550             $subparts = array_map('rawurlencode', $subparts);
551             $parts[$key] = implode('#', $subparts);
552         }
553         $path  = implode('/', $parts);
554         $ffurl = $url.'/'.$path;
555         $separator = '?';
556     } else {
557         $path = rawurlencode('/'.$path);
558         $ffurl = $url.'?file='.$path;
559         $separator = '&amp;';
560     }
562     if ($options) {
563         foreach ($options as $name=>$value) {
564             $ffurl = $ffurl.$separator.$name.'='.$value;
565             $separator = '&amp;';
566         }
567     }
569     return $ffurl;
572 /**
573  * @deprecated use get_enrolled_users($context) instead.
574  */
575 function get_course_participants($courseid) {
576     throw new coding_exception('get_course_participants() can not be used any more, use get_enrolled_users() instead.');
579 /**
580  * @deprecated use is_enrolled($context, $userid) instead.
581  */
582 function is_course_participant($userid, $courseid) {
583     throw new coding_exception('is_course_participant() can not be used any more, use is_enrolled() instead.');
586 /**
587  * @deprecated
588  */
589 function get_recent_enrolments($courseid, $timestart) {
590     throw new coding_exception('get_recent_enrolments() is removed as it returned inaccurate results.');
593 /**
594  * @deprecated use clean_param($string, PARAM_FILE) instead.
595  */
596 function detect_munged_arguments($string, $allowdots=1) {
597     throw new coding_exception('detect_munged_arguments() can not be used any more, please use clean_param(,PARAM_FILE) instead.');
601 /**
602  * Unzip one zip file to a destination dir
603  * Both parameters must be FULL paths
604  * If destination isn't specified, it will be the
605  * SAME directory where the zip file resides.
606  *
607  * @global object
608  * @param string $zipfile The zip file to unzip
609  * @param string $destination The location to unzip to
610  * @param bool $showstatus_ignored Unused
611  */
612 function unzip_file($zipfile, $destination = '', $showstatus_ignored = true) {
613     global $CFG;
615     //Extract everything from zipfile
616     $path_parts = pathinfo(cleardoubleslashes($zipfile));
617     $zippath = $path_parts["dirname"];       //The path of the zip file
618     $zipfilename = $path_parts["basename"];  //The name of the zip file
619     $extension = $path_parts["extension"];    //The extension of the file
621     //If no file, error
622     if (empty($zipfilename)) {
623         return false;
624     }
626     //If no extension, error
627     if (empty($extension)) {
628         return false;
629     }
631     //Clear $zipfile
632     $zipfile = cleardoubleslashes($zipfile);
634     //Check zipfile exists
635     if (!file_exists($zipfile)) {
636         return false;
637     }
639     //If no destination, passed let's go with the same directory
640     if (empty($destination)) {
641         $destination = $zippath;
642     }
644     //Clear $destination
645     $destpath = rtrim(cleardoubleslashes($destination), "/");
647     //Check destination path exists
648     if (!is_dir($destpath)) {
649         return false;
650     }
652     $packer = get_file_packer('application/zip');
654     $result = $packer->extract_to_pathname($zipfile, $destpath);
656     if ($result === false) {
657         return false;
658     }
660     foreach ($result as $status) {
661         if ($status !== true) {
662             return false;
663         }
664     }
666     return true;
669 /**
670  * Zip an array of files/dirs to a destination zip file
671  * Both parameters must be FULL paths to the files/dirs
672  *
673  * @global object
674  * @param array $originalfiles Files to zip
675  * @param string $destination The destination path
676  * @return bool Outcome
677  */
678 function zip_files ($originalfiles, $destination) {
679     global $CFG;
681     //Extract everything from destination
682     $path_parts = pathinfo(cleardoubleslashes($destination));
683     $destpath = $path_parts["dirname"];       //The path of the zip file
684     $destfilename = $path_parts["basename"];  //The name of the zip file
685     $extension = $path_parts["extension"];    //The extension of the file
687     //If no file, error
688     if (empty($destfilename)) {
689         return false;
690     }
692     //If no extension, add it
693     if (empty($extension)) {
694         $extension = 'zip';
695         $destfilename = $destfilename.'.'.$extension;
696     }
698     //Check destination path exists
699     if (!is_dir($destpath)) {
700         return false;
701     }
703     //Check destination path is writable. TODO!!
705     //Clean destination filename
706     $destfilename = clean_filename($destfilename);
708     //Now check and prepare every file
709     $files = array();
710     $origpath = NULL;
712     foreach ($originalfiles as $file) {  //Iterate over each file
713         //Check for every file
714         $tempfile = cleardoubleslashes($file); // no doubleslashes!
715         //Calculate the base path for all files if it isn't set
716         if ($origpath === NULL) {
717             $origpath = rtrim(cleardoubleslashes(dirname($tempfile)), "/");
718         }
719         //See if the file is readable
720         if (!is_readable($tempfile)) {  //Is readable
721             continue;
722         }
723         //See if the file/dir is in the same directory than the rest
724         if (rtrim(cleardoubleslashes(dirname($tempfile)), "/") != $origpath) {
725             continue;
726         }
727         //Add the file to the array
728         $files[] = $tempfile;
729     }
731     $zipfiles = array();
732     $start = strlen($origpath)+1;
733     foreach($files as $file) {
734         $zipfiles[substr($file, $start)] = $file;
735     }
737     $packer = get_file_packer('application/zip');
739     return $packer->archive_to_pathname($zipfiles, $destpath . '/' . $destfilename);
742 /**
743  * @deprecated use groups_get_all_groups() instead.
744  */
745 function mygroupid($courseid) {
746     throw new coding_exception('mygroupid() can not be used any more, please use groups_get_all_groups() instead.');
750 /**
751  * Returns the current group mode for a given course or activity module
752  *
753  * Could be false, SEPARATEGROUPS or VISIBLEGROUPS    (<-- Martin)
754  *
755  * @deprecated since Moodle 2.0 MDL-14617 - please do not use this function any more.
756  * @todo MDL-50273 This will be deleted in Moodle 3.2.
757  *
758  * @param object $course Course Object
759  * @param object $cm Course Manager Object
760  * @return mixed $course->groupmode
761  */
762 function groupmode($course, $cm=null) {
764     debugging('groupmode() is deprecated, please use groups_get_* instead', DEBUG_DEVELOPER);
765     if (isset($cm->groupmode) && empty($course->groupmodeforce)) {
766         return $cm->groupmode;
767     }
768     return $course->groupmode;
771 /**
772  * Sets the current group in the session variable
773  * When $SESSION->currentgroup[$courseid] is set to 0 it means, show all groups.
774  * Sets currentgroup[$courseid] in the session variable appropriately.
775  * Does not do any permission checking.
776  *
777  * @deprecated Since year 2006 - please do not use this function any more.
778  * @todo MDL-50273 This will be deleted in Moodle 3.2.
779  *
780  * @global object
781  * @global object
782  * @param int $courseid The course being examined - relates to id field in
783  * 'course' table.
784  * @param int $groupid The group being examined.
785  * @return int Current group id which was set by this function
786  */
787 function set_current_group($courseid, $groupid) {
788     global $SESSION;
790     debugging('set_current_group() is deprecated, please use $SESSION->currentgroup[$courseid] instead', DEBUG_DEVELOPER);
791     return $SESSION->currentgroup[$courseid] = $groupid;
794 /**
795  * Gets the current group - either from the session variable or from the database.
796  *
797  * @deprecated Since year 2006 - please do not use this function any more.
798  * @todo MDL-50273 This will be deleted in Moodle 3.2.
799  *
800  * @global object
801  * @param int $courseid The course being examined - relates to id field in
802  * 'course' table.
803  * @param bool $full If true, the return value is a full record object.
804  * If false, just the id of the record.
805  * @return int|bool
806  */
807 function get_current_group($courseid, $full = false) {
808     global $SESSION;
810     debugging('get_current_group() is deprecated, please use groups_get_* instead', DEBUG_DEVELOPER);
811     if (isset($SESSION->currentgroup[$courseid])) {
812         if ($full) {
813             return groups_get_group($SESSION->currentgroup[$courseid]);
814         } else {
815             return $SESSION->currentgroup[$courseid];
816         }
817     }
819     $mygroupid = mygroupid($courseid);
820     if (is_array($mygroupid)) {
821         $mygroupid = array_shift($mygroupid);
822         set_current_group($courseid, $mygroupid);
823         if ($full) {
824             return groups_get_group($mygroupid);
825         } else {
826             return $mygroupid;
827         }
828     }
830     if ($full) {
831         return false;
832     } else {
833         return 0;
834     }
837 /**
838  * @deprecated Since Moodle 2.8
839  */
840 function groups_filter_users_by_course_module_visible($cm, $users) {
841     throw new coding_exception('groups_filter_users_by_course_module_visible() is removed. ' .
842             'Replace with a call to \core_availability\info_module::filter_user_list(), ' .
843             'which does basically the same thing but includes other restrictions such ' .
844             'as profile restrictions.');
847 /**
848  * @deprecated Since Moodle 2.8
849  */
850 function groups_course_module_visible($cm, $userid=null) {
851     throw new coding_exception('groups_course_module_visible() is removed, use $cm->uservisible to decide whether the current
852         user can ' . 'access an activity.', DEBUG_DEVELOPER);
855 /**
856  * @deprecated since 2.0
857  */
858 function error($message, $link='') {
859     throw new coding_exception('notlocalisederrormessage', 'error', $link, $message, 'error() is a removed, please call
860             print_error() instead of error()');
864 /**
865  * @deprecated use $PAGE->theme->name instead.
866  */
867 function current_theme() {
868     throw new coding_exception('current_theme() can not be used any more, please use $PAGE->theme->name instead');
871 /**
872  * @deprecated
873  */
874 function formerr($error) {
875     throw new coding_exception('formerr() is removed. Please change your code to use $OUTPUT->error_text($string).');
878 /**
879  * @deprecated use $OUTPUT->skip_link_target() in instead.
880  */
881 function skip_main_destination() {
882     throw new coding_exception('skip_main_destination() can not be used any more, please use $OUTPUT->skip_link_target() instead.');
885 /**
886  * @deprecated use $OUTPUT->container() instead.
887  */
888 function print_container($message, $clearfix=false, $classes='', $idbase='', $return=false) {
889     throw new coding_exception('print_container() can not be used any more. Please use $OUTPUT->container() instead.');
892 /**
893  * @deprecated use $OUTPUT->container_start() instead.
894  */
895 function print_container_start($clearfix=false, $classes='', $idbase='', $return=false) {
896     throw new coding_exception('print_container_start() can not be used any more. Please use $OUTPUT->container_start() instead.');
899 /**
900  * @deprecated use $OUTPUT->container_end() instead.
901  */
902 function print_container_end($return=false) {
903     throw new coding_exception('print_container_end() can not be used any more. Please use $OUTPUT->container_end() instead.');
906 /**
907  * Print a bold message in an optional color.
908  *
909  * @deprecated since Moodle 2.0 MDL-19077 - use $OUTPUT->notification instead.
910  * @todo MDL-50469 This will be deleted in Moodle 3.3.
911  * @param string $message The message to print out
912  * @param string $classes Optional style to display message text in
913  * @param string $align Alignment option
914  * @param bool $return whether to return an output string or echo now
915  * @return string|bool Depending on $result
916  */
917 function notify($message, $classes = 'error', $align = 'center', $return = false) {
918     global $OUTPUT;
920     debugging('notify() is deprecated, please use $OUTPUT->notification() instead', DEBUG_DEVELOPER);
922     if ($classes == 'green') {
923         debugging('Use of deprecated class name "green" in notify. Please change to "success".', DEBUG_DEVELOPER);
924         $classes = 'success'; // Backward compatible with old color system.
925     }
927     $output = $OUTPUT->notification($message, $classes);
928     if ($return) {
929         return $output;
930     } else {
931         echo $output;
932     }
935 /**
936  * @deprecated use $OUTPUT->continue_button() instead.
937  */
938 function print_continue($link, $return = false) {
939     throw new coding_exception('print_continue() can not be used any more. Please use $OUTPUT->continue_button() instead.');
942 /**
943  * @deprecated use $PAGE methods instead.
944  */
945 function print_header($title='', $heading='', $navigation='', $focus='',
946                       $meta='', $cache=true, $button='&nbsp;', $menu=null,
947                       $usexml=false, $bodytags='', $return=false) {
949     throw new coding_exception('print_header() can not be used any more. Please use $PAGE methods instead.');
952 /**
953  * @deprecated use $PAGE methods instead.
954  */
955 function print_header_simple($title='', $heading='', $navigation='', $focus='', $meta='',
956                        $cache=true, $button='&nbsp;', $menu='', $usexml=false, $bodytags='', $return=false) {
958     throw new coding_exception('print_header_simple() can not be used any more. Please use $PAGE methods instead.');
961 /**
962  * @deprecated use $OUTPUT->block() instead.
963  */
964 function print_side_block($heading='', $content='', $list=NULL, $icons=NULL, $footer='', $attributes = array(), $title='') {
965     throw new coding_exception('print_side_block() can not be used any more, please use $OUTPUT->block() instead.');
968 /**
969  * Prints a basic textarea field.
970  *
971  * @deprecated since Moodle 2.0
972  *
973  * When using this function, you should
974  *
975  * @global object
976  * @param bool $unused No longer used.
977  * @param int $rows Number of rows to display  (minimum of 10 when $height is non-null)
978  * @param int $cols Number of columns to display (minimum of 65 when $width is non-null)
979  * @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.
980  * @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.
981  * @param string $name Name to use for the textarea element.
982  * @param string $value Initial content to display in the textarea.
983  * @param int $obsolete deprecated
984  * @param bool $return If false, will output string. If true, will return string value.
985  * @param string $id CSS ID to add to the textarea element.
986  * @return string|void depending on the value of $return
987  */
988 function print_textarea($unused, $rows, $cols, $width, $height, $name, $value='', $obsolete=0, $return=false, $id='') {
989     /// $width and height are legacy fields and no longer used as pixels like they used to be.
990     /// However, you can set them to zero to override the mincols and minrows values below.
992     // Disabling because there is not yet a viable $OUTPUT option for cases when mforms can't be used
993     // debugging('print_textarea() has been deprecated. You should be using mforms and the editor element.');
995     global $CFG;
997     $mincols = 65;
998     $minrows = 10;
999     $str = '';
1001     if ($id === '') {
1002         $id = 'edit-'.$name;
1003     }
1005     if ($height && ($rows < $minrows)) {
1006         $rows = $minrows;
1007     }
1008     if ($width && ($cols < $mincols)) {
1009         $cols = $mincols;
1010     }
1012     editors_head_setup();
1013     $editor = editors_get_preferred_editor(FORMAT_HTML);
1014     $editor->set_text($value);
1015     $editor->use_editor($id, array('legacy'=>true));
1017     $str .= "\n".'<textarea class="form-textarea" id="'. $id .'" name="'. $name .'" rows="'. $rows .'" cols="'. $cols .'" spellcheck="true">'."\n";
1018     $str .= htmlspecialchars($value); // needed for editing of cleaned text!
1019     $str .= '</textarea>'."\n";
1021     if ($return) {
1022         return $str;
1023     }
1024     echo $str;
1027 /**
1028  * Returns an image of an up or down arrow, used for column sorting. To avoid unnecessary DB accesses, please
1029  * provide this function with the language strings for sortasc and sortdesc.
1030  *
1031  * @deprecated use $OUTPUT->arrow() instead.
1032  * @todo final deprecation of this function once MDL-45448 is resolved
1033  *
1034  * If no sort string is associated with the direction, an arrow with no alt text will be printed/returned.
1035  *
1036  * @global object
1037  * @param string $direction 'up' or 'down'
1038  * @param string $strsort The language string used for the alt attribute of this image
1039  * @param bool $return Whether to print directly or return the html string
1040  * @return string|void depending on $return
1041  *
1042  */
1043 function print_arrow($direction='up', $strsort=null, $return=false) {
1044     global $OUTPUT;
1046     debugging('print_arrow() is deprecated. Please use $OUTPUT->arrow() instead.', DEBUG_DEVELOPER);
1048     if (!in_array($direction, array('up', 'down', 'right', 'left', 'move'))) {
1049         return null;
1050     }
1052     $return = null;
1054     switch ($direction) {
1055         case 'up':
1056             $sortdir = 'asc';
1057             break;
1058         case 'down':
1059             $sortdir = 'desc';
1060             break;
1061         case 'move':
1062             $sortdir = 'asc';
1063             break;
1064         default:
1065             $sortdir = null;
1066             break;
1067     }
1069     // Prepare language string
1070     $strsort = '';
1071     if (empty($strsort) && !empty($sortdir)) {
1072         $strsort  = get_string('sort' . $sortdir, 'grades');
1073     }
1075     $return = ' <img src="'.$OUTPUT->pix_url('t/' . $direction) . '" alt="'.$strsort.'" /> ';
1077     if ($return) {
1078         return $return;
1079     } else {
1080         echo $return;
1081     }
1084 /**
1085  * @deprecated since Moodle 2.0
1086  */
1087 function choose_from_menu ($options, $name, $selected='', $nothing='choose', $script='',
1088                            $nothingvalue='0', $return=false, $disabled=false, $tabindex=0,
1089                            $id='', $listbox=false, $multiple=false, $class='') {
1090     throw new coding_exception('choose_from_menu() is removed. Please change your code to use html_writer::select().');
1094 /**
1095  * @deprecated use $OUTPUT->help_icon_scale($courseid, $scale) instead.
1096  */
1097 function print_scale_menu_helpbutton($courseid, $scale, $return=false) {
1098     throw new coding_exception('print_scale_menu_helpbutton() can not be used any more. '.
1099         'Please use $OUTPUT->help_icon_scale($courseid, $scale) instead.');
1102 /**
1103  * @deprecated use html_writer::checkbox() instead.
1104  */
1105 function print_checkbox($name, $value, $checked = true, $label = '', $alt = '', $script='', $return=false) {
1106     throw new coding_exception('print_checkbox() can not be used any more. Please use html_writer::checkbox() instead.');
1109 /**
1110  * Prints the 'update this xxx' button that appears on module pages.
1111  *
1112  * @deprecated since Moodle 2.0
1113  *
1114  * @param string $cmid the course_module id.
1115  * @param string $ignored not used any more. (Used to be courseid.)
1116  * @param string $string the module name - get_string('modulename', 'xxx')
1117  * @return string the HTML for the button, if this user has permission to edit it, else an empty string.
1118  */
1119 function update_module_button($cmid, $ignored, $string) {
1120     global $CFG, $OUTPUT;
1122     // debugging('update_module_button() has been deprecated. Please change your code to use $OUTPUT->update_module_button().');
1124     //NOTE: DO NOT call new output method because it needs the module name we do not have here!
1126     if (has_capability('moodle/course:manageactivities', context_module::instance($cmid))) {
1127         $string = get_string('updatethis', '', $string);
1129         $url = new moodle_url("$CFG->wwwroot/course/mod.php", array('update' => $cmid, 'return' => true, 'sesskey' => sesskey()));
1130         return $OUTPUT->single_button($url, $string);
1131     } else {
1132         return '';
1133     }
1136 /**
1137  * @deprecated use $OUTPUT->navbar() instead
1138  */
1139 function print_navigation ($navigation, $separator=0, $return=false) {
1140     throw new coding_exception('print_navigation() can not be used any more, please update use $OUTPUT->navbar() instead.');
1143 /**
1144  * @deprecated Please use $PAGE->navabar methods instead.
1145  */
1146 function build_navigation($extranavlinks, $cm = null) {
1147     throw new coding_exception('build_navigation() can not be used any more, please use $PAGE->navbar methods instead.');
1150 /**
1151  * @deprecated not relevant with global navigation in Moodle 2.x+
1152  */
1153 function navmenu($course, $cm=NULL, $targetwindow='self') {
1154     throw new coding_exception('navmenu() can not be used any more, it is no longer relevant with global navigation.');
1157 /// CALENDAR MANAGEMENT  ////////////////////////////////////////////////////////////////
1160 /**
1161  * @deprecated please use calendar_event::create() instead.
1162  */
1163 function add_event($event) {
1164     throw new coding_exception('add_event() can not be used any more, please use calendar_event::create() instead.');
1167 /**
1168  * @deprecated please calendar_event->update() instead.
1169  */
1170 function update_event($event) {
1171     throw new coding_exception('update_event() is removed, please use calendar_event->update() instead.');
1174 /**
1175  * @deprecated please use calendar_event->delete() instead.
1176  */
1177 function delete_event($id) {
1178     throw new coding_exception('delete_event() can not be used any more, please use '.
1179         'calendar_event->delete() instead.');
1182 /**
1183  * @deprecated please use calendar_event->toggle_visibility(false) instead.
1184  */
1185 function hide_event($event) {
1186     throw new coding_exception('hide_event() can not be used any more, please use '.
1187         'calendar_event->toggle_visibility(false) instead.');
1190 /**
1191  * @deprecated please use calendar_event->toggle_visibility(true) instead.
1192  */
1193 function show_event($event) {
1194     throw new coding_exception('show_event() can not be used any more, please use '.
1195         'calendar_event->toggle_visibility(true) instead.');
1198 /**
1199  * @deprecated since Moodle 2.2 use core_text::xxxx() instead.
1200  * @see core_text
1201  */
1202 function textlib_get_instance() {
1203     throw new coding_exception('textlib_get_instance() can not be used any more, please use '.
1204         'core_text::functioname() instead.');
1207 /**
1208  * @deprecated since 2.4
1209  * @see get_section_name()
1210  * @see format_base::get_section_name()
1212  */
1213 function get_generic_section_name($format, stdClass $section) {
1214     throw new coding_exception('get_generic_section_name() is deprecated. Please use appropriate functionality from class format_base');
1217 /**
1218  * Returns an array of sections for the requested course id
1219  *
1220  * It is usually not recommended to display the list of sections used
1221  * in course because the course format may have it's own way to do it.
1222  *
1223  * If you need to just display the name of the section please call:
1224  * get_section_name($course, $section)
1225  * {@link get_section_name()}
1226  * from 2.4 $section may also be just the field course_sections.section
1227  *
1228  * If you need the list of all sections it is more efficient to get this data by calling
1229  * $modinfo = get_fast_modinfo($courseorid);
1230  * $sections = $modinfo->get_section_info_all()
1231  * {@link get_fast_modinfo()}
1232  * {@link course_modinfo::get_section_info_all()}
1233  *
1234  * Information about one section (instance of section_info):
1235  * get_fast_modinfo($courseorid)->get_sections_info($section)
1236  * {@link course_modinfo::get_section_info()}
1237  *
1238  * @deprecated since 2.4
1239  */
1240 function get_all_sections($courseid) {
1242     throw new coding_exception('get_all_sections() is removed. See phpdocs for this function');
1245 /**
1246  * This function is deprecated, please use {@link course_add_cm_to_section()}
1247  * Note that course_add_cm_to_section() also updates field course_modules.section and
1248  * calls rebuild_course_cache()
1249  *
1250  * @deprecated since 2.4
1251  */
1252 function add_mod_to_section($mod, $beforemod = null) {
1253     throw new coding_exception('Function add_mod_to_section() is removed, please use course_add_cm_to_section()');
1256 /**
1257  * Returns a number of useful structures for course displays
1258  *
1259  * Function get_all_mods() is deprecated in 2.4
1260  * Instead of:
1261  * <code>
1262  * get_all_mods($courseid, $mods, $modnames, $modnamesplural, $modnamesused);
1263  * </code>
1264  * please use:
1265  * <code>
1266  * $mods = get_fast_modinfo($courseorid)->get_cms();
1267  * $modnames = get_module_types_names();
1268  * $modnamesplural = get_module_types_names(true);
1269  * $modnamesused = get_fast_modinfo($courseorid)->get_used_module_names();
1270  * </code>
1271  *
1272  * @deprecated since 2.4
1273  */
1274 function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused) {
1275     throw new coding_exception('Function get_all_mods() is removed. Use get_fast_modinfo() and get_module_types_names() instead. See phpdocs for details');
1278 /**
1279  * Returns course section - creates new if does not exist yet
1280  *
1281  * This function is deprecated. To create a course section call:
1282  * course_create_sections_if_missing($courseorid, $sections);
1283  * to get the section call:
1284  * get_fast_modinfo($courseorid)->get_section_info($sectionnum);
1285  *
1286  * @see course_create_sections_if_missing()
1287  * @see get_fast_modinfo()
1288  * @deprecated since 2.4
1289  */
1290 function get_course_section($section, $courseid) {
1291     throw new coding_exception('Function get_course_section() is removed. Please use course_create_sections_if_missing() and get_fast_modinfo() instead.');
1294 /**
1295  * @deprecated since 2.4
1296  * @see format_weeks::get_section_dates()
1297  */
1298 function format_weeks_get_section_dates($section, $course) {
1299     throw new coding_exception('Function format_weeks_get_section_dates() is removed. It is not recommended to'.
1300             ' use it outside of format_weeks plugin');
1303 /**
1304  * Deprecated. Instead of:
1305  * list($content, $name) = get_print_section_cm_text($cm, $course);
1306  * use:
1307  * $content = $cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true));
1308  * $name = $cm->get_formatted_name();
1309  *
1310  * @deprecated since 2.5
1311  * @see cm_info::get_formatted_content()
1312  * @see cm_info::get_formatted_name()
1313  */
1314 function get_print_section_cm_text(cm_info $cm, $course) {
1315     throw new coding_exception('Function get_print_section_cm_text() is removed. Please use '.
1316             'cm_info::get_formatted_content() and cm_info::get_formatted_name()');
1319 /**
1320  * Deprecated. Please use:
1321  * $courserenderer = $PAGE->get_renderer('core', 'course');
1322  * $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn,
1323  *    array('inblock' => $vertical));
1324  * echo $output;
1325  *
1326  * @deprecated since 2.5
1327  * @see core_course_renderer::course_section_add_cm_control()
1328  */
1329 function print_section_add_menus($course, $section, $modnames = null, $vertical=false, $return=false, $sectionreturn=null) {
1330     throw new coding_exception('Function print_section_add_menus() is removed. Please use course renderer '.
1331             'function course_section_add_cm_control()');
1334 /**
1335  * Deprecated. Please use:
1336  * $courserenderer = $PAGE->get_renderer('core', 'course');
1337  * $actions = course_get_cm_edit_actions($mod, $indent, $section);
1338  * return ' ' . $courserenderer->course_section_cm_edit_actions($actions);
1339  *
1340  * @deprecated since 2.5
1341  * @see course_get_cm_edit_actions()
1342  * @see core_course_renderer->course_section_cm_edit_actions()
1343  */
1344 function make_editing_buttons(stdClass $mod, $absolute_ignored = true, $moveselect = true, $indent=-1, $section=null) {
1345     throw new coding_exception('Function make_editing_buttons() is removed, please see PHPdocs in '.
1346             'lib/deprecatedlib.php on how to replace it');
1349 /**
1350  * Deprecated. Please use:
1351  * $courserenderer = $PAGE->get_renderer('core', 'course');
1352  * echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn,
1353  *     array('hidecompletion' => $hidecompletion));
1354  *
1355  * @deprecated since 2.5
1356  * @see core_course_renderer::course_section_cm_list()
1357  */
1358 function print_section($course, $section, $mods, $modnamesused, $absolute=false, $width="100%", $hidecompletion=false, $sectionreturn=null) {
1359     throw new coding_exception('Function print_section() is removed. Please use course renderer function '.
1360             'course_section_cm_list() instead.');
1363 /**
1364  * @deprecated since 2.5
1365  */
1366 function print_overview($courses, array $remote_courses=array()) {
1367     throw new coding_exception('Function print_overview() is removed. Use block course_overview to display this information');
1370 /**
1371  * @deprecated since 2.5
1372  */
1373 function print_recent_activity($course) {
1374     throw new coding_exception('Function print_recent_activity() is removed. It is not recommended to'.
1375             ' use it outside of block_recent_activity');
1378 /**
1379  * @deprecated since 2.5
1380  */
1381 function delete_course_module($id) {
1382     throw new coding_exception('Function delete_course_module() is removed. Please use course_delete_module() instead.');
1385 /**
1386  * @deprecated since 2.5
1387  */
1388 function update_category_button($categoryid = 0) {
1389     throw new coding_exception('Function update_category_button() is removed. Pages to view '.
1390             'and edit courses are now separate and no longer depend on editing mode.');
1393 /**
1394  * This function is deprecated! For list of categories use
1395  * coursecat::make_all_categories($requiredcapability, $excludeid, $separator)
1396  * For parents of one particular category use
1397  * coursecat::get($id)->get_parents()
1398  *
1399  * @deprecated since 2.5
1400  */
1401 function make_categories_list(&$list, &$parents, $requiredcapability = '',
1402         $excludeid = 0, $category = NULL, $path = "") {
1403     throw new coding_exception('Global function make_categories_list() is removed. Please use '.
1404             'coursecat::make_categories_list() and coursecat::get_parents()');
1407 /**
1408  * @deprecated since 2.5
1409  */
1410 function category_delete_move($category, $newparentid, $showfeedback=true) {
1411     throw new coding_exception('Function category_delete_move() is removed. Please use coursecat::delete_move() instead.');
1414 /**
1415  * @deprecated since 2.5
1416  */
1417 function category_delete_full($category, $showfeedback=true) {
1418     throw new coding_exception('Function category_delete_full() is removed. Please use coursecat::delete_full() instead.');
1421 /**
1422  * This function is deprecated. Please use
1423  * $coursecat = coursecat::get($category->id);
1424  * if ($coursecat->can_change_parent($newparentcat->id)) {
1425  *     $coursecat->change_parent($newparentcat->id);
1426  * }
1427  *
1428  * Alternatively you can use
1429  * $coursecat->update(array('parent' => $newparentcat->id));
1430  *
1431  * @see coursecat::change_parent()
1432  * @see coursecat::update()
1433  * @deprecated since 2.5
1434  */
1435 function move_category($category, $newparentcat) {
1436     throw new coding_exception('Function move_category() is removed. Please use coursecat::change_parent() instead.');
1439 /**
1440  * This function is deprecated. Please use
1441  * coursecat::get($category->id)->hide();
1442  *
1443  * @see coursecat::hide()
1444  * @deprecated since 2.5
1445  */
1446 function course_category_hide($category) {
1447     throw new coding_exception('Function course_category_hide() is removed. Please use coursecat::hide() instead.');
1450 /**
1451  * This function is deprecated. Please use
1452  * coursecat::get($category->id)->show();
1453  *
1454  * @see coursecat::show()
1455  * @deprecated since 2.5
1456  */
1457 function course_category_show($category) {
1458     throw new coding_exception('Function course_category_show() is removed. Please use coursecat::show() instead.');
1461 /**
1462  * This function is deprecated.
1463  * To get the category with the specified it please use:
1464  * coursecat::get($catid, IGNORE_MISSING);
1465  * or
1466  * coursecat::get($catid, MUST_EXIST);
1467  *
1468  * To get the first available category please use
1469  * coursecat::get_default();
1470  *
1471  * @deprecated since 2.5
1472  */
1473 function get_course_category($catid=0) {
1474     throw new coding_exception('Function get_course_category() is removed. Please use coursecat::get(), see phpdocs for more details');
1477 /**
1478  * This function is deprecated. It is replaced with the method create() in class coursecat.
1479  * {@link coursecat::create()} also verifies the data, fixes sortorder and logs the action
1480  *
1481  * @deprecated since 2.5
1482  */
1483 function create_course_category($category) {
1484     throw new coding_exception('Function create_course_category() is removed. Please use coursecat::create(), see phpdocs for more details');
1487 /**
1488  * This function is deprecated.
1489  *
1490  * To get visible children categories of the given category use:
1491  * coursecat::get($categoryid)->get_children();
1492  * This function will return the array or coursecat objects, on each of them
1493  * you can call get_children() again
1494  *
1495  * @see coursecat::get()
1496  * @see coursecat::get_children()
1497  *
1498  * @deprecated since 2.5
1499  */
1500 function get_all_subcategories($catid) {
1501     throw new coding_exception('Function get_all_subcategories() is removed. Please use appropriate methods() of coursecat
1502             class. See phpdocs for more details');
1505 /**
1506  * This function is deprecated. Please use functions in class coursecat:
1507  * - coursecat::get($parentid)->has_children()
1508  * tells if the category has children (visible or not to the current user)
1509  *
1510  * - coursecat::get($parentid)->get_children()
1511  * returns an array of coursecat objects, each of them represents a children category visible
1512  * to the current user (i.e. visible=1 or user has capability to view hidden categories)
1513  *
1514  * - coursecat::get($parentid)->get_children_count()
1515  * returns number of children categories visible to the current user
1516  *
1517  * - coursecat::count_all()
1518  * returns total count of all categories in the system (both visible and not)
1519  *
1520  * - coursecat::get_default()
1521  * returns the first category (usually to be used if count_all() == 1)
1522  *
1523  * @deprecated since 2.5
1524  */
1525 function get_child_categories($parentid) {
1526     throw new coding_exception('Function get_child_categories() is removed. Use coursecat::get_children() or see phpdocs for
1527             more details.');
1530 /**
1531  *
1532  * @deprecated since 2.5
1533  *
1534  * This function is deprecated. Use appropriate functions from class coursecat.
1535  * Examples:
1536  *
1537  * coursecat::get($categoryid)->get_children()
1538  * - returns all children of the specified category as instances of class
1539  * coursecat, which means on each of them method get_children() can be called again.
1540  * Only categories visible to the current user are returned.
1541  *
1542  * coursecat::get(0)->get_children()
1543  * - returns all top-level categories visible to the current user.
1544  *
1545  * Sort fields can be specified, see phpdocs to {@link coursecat::get_children()}
1546  *
1547  * coursecat::make_categories_list()
1548  * - returns an array of all categories id/names in the system.
1549  * Also only returns categories visible to current user and can additionally be
1550  * filetered by capability, see phpdocs to {@link coursecat::make_categories_list()}
1551  *
1552  * make_categories_options()
1553  * - Returns full course categories tree to be used in html_writer::select()
1554  *
1555  * Also see functions {@link coursecat::get_children_count()}, {@link coursecat::count_all()},
1556  * {@link coursecat::get_default()}
1557  */
1558 function get_categories($parent='none', $sort=NULL, $shallow=true) {
1559     throw new coding_exception('Function get_categories() is removed. Please use coursecat::get_children() or see phpdocs for other alternatives');
1562 /**
1563 * This function is deprecated, please use course renderer:
1564 * $renderer = $PAGE->get_renderer('core', 'course');
1565 * echo $renderer->course_search_form($value, $format);
1567 * @deprecated since 2.5
1568 */
1569 function print_course_search($value="", $return=false, $format="plain") {
1570     throw new coding_exception('Function print_course_search() is removed, please use course renderer');
1573 /**
1574  * This function is deprecated, please use:
1575  * $renderer = $PAGE->get_renderer('core', 'course');
1576  * echo $renderer->frontpage_my_courses()
1577  *
1578  * @deprecated since 2.5
1579  */
1580 function print_my_moodle() {
1581     throw new coding_exception('Function print_my_moodle() is removed, please use course renderer function frontpage_my_courses()');
1584 /**
1585  * This function is deprecated, it is replaced with protected function
1586  * {@link core_course_renderer::frontpage_remote_course()}
1587  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
1588  *
1589  * @deprecated since 2.5
1590  */
1591 function print_remote_course($course, $width="100%") {
1592     throw new coding_exception('Function print_remote_course() is removed, please use course renderer');
1595 /**
1596  * This function is deprecated, it is replaced with protected function
1597  * {@link core_course_renderer::frontpage_remote_host()}
1598  * It is only used from function {@link core_course_renderer::frontpage_my_courses()}
1599  *
1600  * @deprecated since 2.5
1601  */
1602 function print_remote_host($host, $width="100%") {
1603     throw new coding_exception('Function print_remote_host() is removed, please use course renderer');
1606 /**
1607  * @deprecated since 2.5
1608  *
1609  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
1610  */
1611 function print_whole_category_list($category=NULL, $displaylist=NULL, $parentslist=NULL, $depth=-1, $showcourses = true, $categorycourses=NULL) {
1612     throw new coding_exception('Function print_whole_category_list() is removed, please use course renderer');
1615 /**
1616  * @deprecated since 2.5
1617  */
1618 function print_category_info($category, $depth = 0, $showcourses = false, array $courses = null) {
1619     throw new coding_exception('Function print_category_info() is removed, please use course renderer');
1622 /**
1623  * @deprecated since 2.5
1624  *
1625  * This function is not used any more in moodle core and course renderer does not have render function for it.
1626  * Combo list on the front page is displayed as:
1627  * $renderer = $PAGE->get_renderer('core', 'course');
1628  * echo $renderer->frontpage_combo_list()
1629  *
1630  * The new class {@link coursecat} stores the information about course category tree
1631  * To get children categories use:
1632  * coursecat::get($id)->get_children()
1633  * To get list of courses use:
1634  * coursecat::get($id)->get_courses()
1635  *
1636  * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5
1637  */
1638 function get_course_category_tree($id = 0, $depth = 0) {
1639     throw new coding_exception('Function get_course_category_tree() is removed, please use course renderer or coursecat class,
1640             see function phpdocs for more info');
1643 /**
1644  * @deprecated since 2.5
1645  *
1646  * To print a generic list of courses use:
1647  * $renderer = $PAGE->get_renderer('core', 'course');
1648  * echo $renderer->courses_list($courses);
1649  *
1650  * To print list of all courses:
1651  * $renderer = $PAGE->get_renderer('core', 'course');
1652  * echo $renderer->frontpage_available_courses();
1653  *
1654  * To print list of courses inside category:
1655  * $renderer = $PAGE->get_renderer('core', 'course');
1656  * echo $renderer->course_category($category); // this will also print subcategories
1657  */
1658 function print_courses($category) {
1659     throw new coding_exception('Function print_courses() is removed, please use course renderer');
1662 /**
1663  * @deprecated since 2.5
1664  *
1665  * Please use course renderer to display a course information box.
1666  * $renderer = $PAGE->get_renderer('core', 'course');
1667  * echo $renderer->courses_list($courses); // will print list of courses
1668  * echo $renderer->course_info_box($course); // will print one course wrapped in div.generalbox
1669  */
1670 function print_course($course, $highlightterms = '') {
1671     throw new coding_exception('Function print_course() is removed, please use course renderer');
1674 /**
1675  * @deprecated since 2.5
1676  *
1677  * This function is not used any more in moodle core and course renderer does not have render function for it.
1678  * Combo list on the front page is displayed as:
1679  * $renderer = $PAGE->get_renderer('core', 'course');
1680  * echo $renderer->frontpage_combo_list()
1681  *
1682  * The new class {@link coursecat} stores the information about course category tree
1683  * To get children categories use:
1684  * coursecat::get($id)->get_children()
1685  * To get list of courses use:
1686  * coursecat::get($id)->get_courses()
1687  */
1688 function get_category_courses_array($categoryid = 0) {
1689     throw new coding_exception('Function get_category_courses_array() is removed, please use methods of coursecat class');
1692 /**
1693  * @deprecated since 2.5
1694  */
1695 function get_category_courses_array_recursively(array &$flattened, $category) {
1696     throw new coding_exception('Function get_category_courses_array_recursively() is removed, please use methods of coursecat class', DEBUG_DEVELOPER);
1699 /**
1700  * @deprecated since Moodle 2.5 MDL-27814 - please do not use this function any more.
1701  */
1702 function blog_get_context_url($context=null) {
1703     throw new coding_exception('Function  blog_get_context_url() is removed, getting params from context is not reliable for blogs.');
1706 /**
1707  * @deprecated since 2.5
1708  *
1709  * To get list of all courses with course contacts ('managers') use
1710  * coursecat::get(0)->get_courses(array('recursive' => true, 'coursecontacts' => true));
1711  *
1712  * To get list of courses inside particular category use
1713  * coursecat::get($id)->get_courses(array('coursecontacts' => true));
1714  *
1715  * Additionally you can specify sort order, offset and maximum number of courses,
1716  * see {@link coursecat::get_courses()}
1717  */
1718 function get_courses_wmanagers($categoryid=0, $sort="c.sortorder ASC", $fields=array()) {
1719     throw new coding_exception('Function get_courses_wmanagers() is removed, please use coursecat::get_courses()');
1722 /**
1723  * @deprecated since 2.5
1724  */
1725 function convert_tree_to_html($tree, $row=0) {
1726     throw new coding_exception('Function convert_tree_to_html() is removed. Consider using class tabtree and core_renderer::render_tabtree()');
1729 /**
1730  * @deprecated since 2.5
1731  */
1732 function convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated) {
1733     throw new coding_exception('Function convert_tabrows_to_tree() is removed. Consider using class tabtree');
1736 /**
1737  * @deprecated since 2.5 - do not use, the textrotate.js will work it out automatically
1738  */
1739 function can_use_rotated_text() {
1740     debugging('can_use_rotated_text() is removed. JS feature detection is used automatically.');
1743 /**
1744  * @deprecated since Moodle 2.2 MDL-35009 - please do not use this function any more.
1745  * @see context::instance_by_id($id)
1746  */
1747 function get_context_instance_by_id($id, $strictness = IGNORE_MISSING) {
1748     throw new coding_exception('get_context_instance_by_id() is now removed, please use context::instance_by_id($id) instead.');
1751 /**
1752  * Returns system context or null if can not be created yet.
1753  *
1754  * @see context_system::instance()
1755  * @deprecated since 2.2
1756  * @param bool $cache use caching
1757  * @return context system context (null if context table not created yet)
1758  */
1759 function get_system_context($cache = true) {
1760     debugging('get_system_context() is deprecated, please use context_system::instance() instead.', DEBUG_DEVELOPER);
1761     return context_system::instance(0, IGNORE_MISSING, $cache);
1764 /**
1765  * @see context::get_parent_context_ids()
1766  * @deprecated since 2.2, use $context->get_parent_context_ids() instead
1767  */
1768 function get_parent_contexts(context $context, $includeself = false) {
1769     throw new coding_exception('get_parent_contexts() is removed, please use $context->get_parent_context_ids() instead.');
1772 /**
1773  * @deprecated since Moodle 2.2
1774  * @see context::get_parent_context()
1775  */
1776 function get_parent_contextid(context $context) {
1777     throw new coding_exception('get_parent_contextid() is removed, please use $context->get_parent_context() instead.');
1780 /**
1781  * @see context::get_child_contexts()
1782  * @deprecated since 2.2
1783  */
1784 function get_child_contexts(context $context) {
1785     throw new coding_exception('get_child_contexts() is removed, please use $context->get_child_contexts() instead.');
1788 /**
1789  * @see context_helper::create_instances()
1790  * @deprecated since 2.2
1791  */
1792 function create_contexts($contextlevel = null, $buildpaths = true) {
1793     throw new coding_exception('create_contexts() is removed, please use context_helper::create_instances() instead.');
1796 /**
1797  * @see context_helper::cleanup_instances()
1798  * @deprecated since 2.2
1799  */
1800 function cleanup_contexts() {
1801     throw new coding_exception('cleanup_contexts() is removed, please use context_helper::cleanup_instances() instead.');
1804 /**
1805  * Populate context.path and context.depth where missing.
1806  *
1807  * @deprecated since 2.2
1808  */
1809 function build_context_path($force = false) {
1810     throw new coding_exception('build_context_path() is removed, please use context_helper::build_all_paths() instead.');
1813 /**
1814  * @deprecated since 2.2
1815  */
1816 function rebuild_contexts(array $fixcontexts) {
1817     throw new coding_exception('rebuild_contexts() is removed, please use $context->reset_paths(true) instead.');
1820 /**
1821  * @deprecated since Moodle 2.2
1822  * @see context_helper::preload_course()
1823  */
1824 function preload_course_contexts($courseid) {
1825     throw new coding_exception('preload_course_contexts() is removed, please use context_helper::preload_course() instead.');
1828 /**
1829  * @deprecated since Moodle 2.2
1830  * @see context::update_moved()
1831  */
1832 function context_moved(context $context, context $newparent) {
1833     throw new coding_exception('context_moved() is removed, please use context::update_moved() instead.');
1836 /**
1837  * @see context::get_capabilities()
1838  * @deprecated since 2.2
1839  */
1840 function fetch_context_capabilities(context $context) {
1841     throw new coding_exception('fetch_context_capabilities() is removed, please use $context->get_capabilities() instead.');
1844 /**
1845  * @deprecated since 2.2
1846  * @see context_helper::preload_from_record()
1847  */
1848 function context_instance_preload(stdClass $rec) {
1849     throw new coding_exception('context_instance_preload() is removed, please use context_helper::preload_from_record() instead.');
1852 /**
1853  * Returns context level name
1854  *
1855  * @deprecated since 2.2
1856  * @see context_helper::get_level_name()
1857  */
1858 function get_contextlevel_name($contextlevel) {
1859     throw new coding_exception('get_contextlevel_name() is removed, please use context_helper::get_level_name() instead.');
1862 /**
1863  * @deprecated since 2.2
1864  * @see context::get_context_name()
1865  */
1866 function print_context_name(context $context, $withprefix = true, $short = false) {
1867     throw new coding_exception('print_context_name() is removed, please use $context->get_context_name() instead.');
1870 /**
1871  * @deprecated since 2.2, use $context->mark_dirty() instead
1872  * @see context::mark_dirty()
1873  */
1874 function mark_context_dirty($path) {
1875     throw new coding_exception('mark_context_dirty() is removed, please use $context->mark_dirty() instead.');
1878 /**
1879  * @deprecated since Moodle 2.2
1880  * @see context_helper::delete_instance() or context::delete_content()
1881  */
1882 function delete_context($contextlevel, $instanceid, $deleterecord = true) {
1883     if ($deleterecord) {
1884         throw new coding_exception('delete_context() is removed, please use context_helper::delete_instance() instead.');
1885     } else {
1886         throw new coding_exception('delete_context() is removed, please use $context->delete_content() instead.');
1887     }
1890 /**
1891  * @deprecated since 2.2
1892  * @see context::get_url()
1893  */
1894 function get_context_url(context $context) {
1895     throw new coding_exception('get_context_url() is removed, please use $context->get_url() instead.');
1898 /**
1899  * @deprecated since 2.2
1900  * @see context::get_course_context()
1901  */
1902 function get_course_context(context $context) {
1903     throw new coding_exception('get_course_context() is removed, please use $context->get_course_context(true) instead.');
1906 /**
1907  * @deprecated since 2.2
1908  * @see enrol_get_users_courses()
1909  */
1910 function get_user_courses_bycap($userid, $cap, $accessdata_ignored, $doanything_ignored, $sort = 'c.sortorder ASC', $fields = null, $limit_ignored = 0) {
1912     throw new coding_exception('get_user_courses_bycap() is removed, please use enrol_get_users_courses() instead.');
1915 /**
1916  * @deprecated since Moodle 2.2
1917  */
1918 function get_role_context_caps($roleid, context $context) {
1919     throw new coding_exception('get_role_context_caps() is removed, it is really slow. Don\'t use it.');
1922 /**
1923  * @see context::get_course_context()
1924  * @deprecated since 2.2
1925  */
1926 function get_courseid_from_context(context $context) {
1927     throw new coding_exception('get_courseid_from_context() is removed, please use $context->get_course_context(false) instead.');
1930 /**
1931  * If you are using this methid, you should have something like this:
1932  *
1933  *    list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
1934  *
1935  * To prevent the use of this deprecated function, replace the line above with something similar to this:
1936  *
1937  *    $ctxselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
1938  *                                                                        ^
1939  *    $ctxjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
1940  *                                    ^       ^                ^        ^
1941  *    $params = array('contextlevel' => CONTEXT_COURSE);
1942  *                                      ^
1943  * @see context_helper:;get_preload_record_columns_sql()
1944  * @deprecated since 2.2
1945  */
1946 function context_instance_preload_sql($joinon, $contextlevel, $tablealias) {
1947     throw new coding_exception('context_instance_preload_sql() is removed, please use context_helper::get_preload_record_columns_sql() instead.');
1950 /**
1951  * @deprecated since 2.2
1952  * @see context::get_parent_context_ids()
1953  */
1954 function get_related_contexts_string(context $context) {
1955     throw new coding_exception('get_related_contexts_string() is removed, please use $context->get_parent_context_ids(true) instead.');
1958 /**
1959  * @deprecated since 2.6
1960  * @see core_component::get_plugin_list_with_file()
1961  */
1962 function get_plugin_list_with_file($plugintype, $file, $include = false) {
1963     throw new coding_exception('get_plugin_list_with_file() is removed, please use core_component::get_plugin_list_with_file() instead.');
1966 /**
1967  * @deprecated since 2.6
1968  */
1969 function check_browser_operating_system($brand) {
1970     throw new coding_exception('check_browser_operating_system is removed, please update your code to use core_useragent instead.');
1973 /**
1974  * @deprecated since 2.6
1975  */
1976 function check_browser_version($brand, $version = null) {
1977     throw new coding_exception('check_browser_version is removed, please update your code to use core_useragent instead.');
1980 /**
1981  * @deprecated since 2.6
1982  */
1983 function get_device_type() {
1984     throw new coding_exception('get_device_type is removed, please update your code to use core_useragent instead.');
1987 /**
1988  * @deprecated since 2.6
1989  */
1990 function get_device_type_list($incusertypes = true) {
1991     throw new coding_exception('get_device_type_list is removed, please update your code to use core_useragent instead.');
1994 /**
1995  * @deprecated since 2.6
1996  */
1997 function get_selected_theme_for_device_type($devicetype = null) {
1998     throw new coding_exception('get_selected_theme_for_device_type is removed, please update your code to use core_useragent instead.');
2001 /**
2002  * @deprecated since 2.6
2003  */
2004 function get_device_cfg_var_name($devicetype = null) {
2005     throw new coding_exception('get_device_cfg_var_name is removed, please update your code to use core_useragent instead.');
2008 /**
2009  * @deprecated since 2.6
2010  */
2011 function set_user_device_type($newdevice) {
2012     throw new coding_exception('set_user_device_type is removed, please update your code to use core_useragent instead.');
2015 /**
2016  * @deprecated since 2.6
2017  */
2018 function get_user_device_type() {
2019     throw new coding_exception('get_user_device_type is removed, please update your code to use core_useragent instead.');
2022 /**
2023  * @deprecated since 2.6
2024  */
2025 function get_browser_version_classes() {
2026     throw new coding_exception('get_browser_version_classes is removed, please update your code to use core_useragent instead.');
2029 /**
2030  * @deprecated since Moodle 2.6
2031  * @see core_user::get_support_user()
2032  */
2033 function generate_email_supportuser() {
2034     throw new coding_exception('generate_email_supportuser is removed, please use core_user::get_support_user');
2037 /**
2038  * @deprecated since Moodle 2.6
2039  */
2040 function badges_get_issued_badge_info($hash) {
2041     throw new coding_exception('Function badges_get_issued_badge_info() is removed. Please use core_badges_assertion class and methods to generate badge assertion.');
2044 /**
2045  * @deprecated since 2.6
2046  */
2047 function can_use_html_editor() {
2048     throw new coding_exception('can_use_html_editor is removed, please update your code to assume it returns true.');
2052 /**
2053  * @deprecated since Moodle 2.7, use {@link user_count_login_failures()} instead.
2054  */
2055 function count_login_failures($mode, $username, $lastlogin) {
2056     throw new coding_exception('count_login_failures() can not be used any more, please use user_count_login_failures().');
2059 /**
2060  * @deprecated since 2.7 MDL-33099/MDL-44088 - please do not use this function any more.
2061  */
2062 function ajaxenabled(array $browsers = null) {
2063     throw new coding_exception('ajaxenabled() can not be used anymore. Update your code to work with JS at all times.');
2066 /**
2067  * @deprecated Since Moodle 2.7 MDL-44070
2068  */
2069 function coursemodule_visible_for_user($cm, $userid=0) {
2070     throw new coding_exception('coursemodule_visible_for_user() can not be used any more,
2071             please use \core_availability\info_module::is_user_visible()');
2074 /**
2075  * @deprecated since Moodle 2.8 MDL-36014, MDL-35618 this functionality is removed
2076  */
2077 function enrol_cohort_get_cohorts(course_enrolment_manager $manager) {
2078     throw new coding_exception('Function enrol_cohort_get_cohorts() is removed, use enrol_cohort_search_cohorts() or '.
2079         'cohort_get_available_cohorts() instead');
2082 /**
2083  * This function is deprecated, use {@link cohort_can_view_cohort()} instead since it also
2084  * takes into account current context
2085  *
2086  * @deprecated since Moodle 2.8 MDL-36014 please use cohort_can_view_cohort()
2087  */
2088 function enrol_cohort_can_view_cohort($cohortid) {
2089     throw new coding_exception('Function enrol_cohort_can_view_cohort() is removed, use cohort_can_view_cohort() instead');
2092 /**
2093  * It is advisable to use {@link cohort_get_available_cohorts()} instead.
2094  *
2095  * @deprecated since Moodle 2.8 MDL-36014 use cohort_get_available_cohorts() instead
2096  */
2097 function cohort_get_visible_list($course, $onlyenrolled=true) {
2098     throw new coding_exception('Function cohort_get_visible_list() is removed. Please use function cohort_get_available_cohorts() ".
2099         "that correctly checks capabilities.');
2102 /**
2103  * @deprecated since Moodle 2.8 MDL-35618 this functionality is removed
2104  */
2105 function enrol_cohort_enrol_all_users(course_enrolment_manager $manager, $cohortid, $roleid) {
2106     throw new coding_exception('enrol_cohort_enrol_all_users() is removed. This functionality is moved to enrol_manual.');
2109 /**
2110  * @deprecated since Moodle 2.8 MDL-35618 this functionality is removed
2111  */
2112 function enrol_cohort_search_cohorts(course_enrolment_manager $manager, $offset = 0, $limit = 25, $search = '') {
2113     throw new coding_exception('enrol_cohort_search_cohorts() is removed. This functionality is moved to enrol_manual.');
2116 /* === Apis deprecated in since Moodle 2.9 === */
2118 /**
2119  * Is $USER one of the supplied users?
2120  *
2121  * $user2 will be null if viewing a user's recent conversations
2122  *
2123  * @deprecated since Moodle 2.9 MDL-49371 - please do not use this function any more.
2124  */
2125 function message_current_user_is_involved($user1, $user2) {
2126     throw new coding_exception('message_current_user_is_involved() can not be used any more.');
2129 /**
2130  * Print badges on user profile page.
2131  *
2132  * @deprecated since Moodle 2.9 MDL-45898 - please do not use this function any more.
2133  */
2134 function profile_display_badges($userid, $courseid = 0) {
2135     throw new coding_exception('profile_display_badges() can not be used any more.');
2138 /**
2139  * Adds user preferences elements to user edit form.
2140  *
2141  * @deprecated since Moodle 2.9 MDL-45774 - Please do not use this function any more.
2142  */
2143 function useredit_shared_definition_preferences($user, &$mform, $editoroptions = null, $filemanageroptions = null) {
2144     throw new coding_exception('useredit_shared_definition_preferences() can not be used any more.');
2148 /**
2149  * Convert region timezone to php supported timezone
2150  *
2151  * @deprecated since Moodle 2.9
2152  */
2153 function calendar_normalize_tz($tz) {
2154     throw new coding_exception('calendar_normalize_tz() can not be used any more, please use core_date::normalise_timezone() instead.');
2157 /**
2158  * Returns a float which represents the user's timezone difference from GMT in hours
2159  * Checks various settings and picks the most dominant of those which have a value
2160  * @deprecated since Moodle 2.9
2161  */
2162 function get_user_timezone_offset($tz = 99) {
2163     throw new coding_exception('get_user_timezone_offset() can not be used any more, please use standard PHP DateTimeZone class instead');
2167 /**
2168  * Returns an int which represents the systems's timezone difference from GMT in seconds
2169  * @deprecated since Moodle 2.9
2170  */
2171 function get_timezone_offset($tz) {
2172     throw new coding_exception('get_timezone_offset() can not be used any more, please use standard PHP DateTimeZone class instead');
2175 /**
2176  * Returns a list of timezones in the current language.
2177  * @deprecated since Moodle 2.9
2178  */
2179 function get_list_of_timezones() {
2180     throw new coding_exception('get_list_of_timezones() can not be used any more, please use core_date::get_list_of_timezones() instead');
2183 /**
2184  * Previous internal API, it was not supposed to be used anywhere.
2185  * @deprecated since Moodle 2.9
2186  */
2187 function update_timezone_records($timezones) {
2188     throw new coding_exception('update_timezone_records() can not be used any more, please use standard PHP DateTime class instead');
2191 /**
2192  * Previous internal API, it was not supposed to be used anywhere.
2193  * @deprecated since Moodle 2.9
2194  */
2195 function calculate_user_dst_table($fromyear = null, $toyear = null, $strtimezone = null) {
2196     throw new coding_exception('calculate_user_dst_table() can not be used any more, please use standard PHP DateTime class instead');
2199 /**
2200  * Previous internal API, it was not supposed to be used anywhere.
2201  * @deprecated since Moodle 2.9
2202  */
2203 function dst_changes_for_year($year, $timezone) {
2204     throw new coding_exception('dst_changes_for_year() can not be used any more, please use standard DateTime class instead');
2207 /**
2208  * Previous internal API, it was not supposed to be used anywhere.
2209  * @deprecated since Moodle 2.9
2210  */
2211 function get_timezone_record($timezonename) {
2212     throw new coding_exception('get_timezone_record() can not be used any more, please use standard PHP DateTime class instead');
2215 /* === Apis deprecated since Moodle 3.0 === */
2216 /**
2217  * Returns the URL of the HTTP_REFERER, less the querystring portion if required.
2218  *
2219  * @deprecated since Moodle 3.0 MDL-49360 - please do not use this function any more.
2220  * @todo MDL-50265 Remove this function in Moodle 3.4.
2221  * @param boolean $stripquery if true, also removes the query part of the url.
2222  * @return string The resulting referer or empty string.
2223  */
2224 function get_referer($stripquery = true) {
2225     debugging('get_referer() is deprecated. Please use get_local_referer() instead.', DEBUG_DEVELOPER);
2226     if (isset($_SERVER['HTTP_REFERER'])) {
2227         if ($stripquery) {
2228             return strip_querystring($_SERVER['HTTP_REFERER']);
2229         } else {
2230             return $_SERVER['HTTP_REFERER'];
2231         }
2232     } else {
2233         return '';
2234     }
2237 /**
2238  * Checks if current user is a web crawler.
2239  *
2240  * This list can not be made complete, this is not a security
2241  * restriction, we make the list only to help these sites
2242  * especially when automatic guest login is disabled.
2243  *
2244  * If admin needs security they should enable forcelogin
2245  * and disable guest access!!
2246  *
2247  * @return bool
2248  * @deprecated since Moodle 3.0 use \core_useragent::is_web_crawler instead.
2249  */
2250 function is_web_crawler() {
2251     debugging('is_web_crawler() has been deprecated, please use core_useragent::is_web_crawler() instead.', DEBUG_DEVELOPER);
2252     return core_useragent::is_web_crawler();
2255 /**
2256  * Update user's course completion statuses
2257  *
2258  * First update all criteria completions, then aggregate all criteria completions
2259  * and update overall course completions.
2260  *
2261  * @deprecated since Moodle 3.0 MDL-50287 - please do not use this function any more.
2262  * @todo Remove this function in Moodle 3.2 MDL-51226.
2263  */
2264 function completion_cron() {
2265     global $CFG;
2266     require_once($CFG->dirroot.'/completion/cron.php');
2268     debugging('completion_cron() is deprecated. Functionality has been moved to scheduled tasks.', DEBUG_DEVELOPER);
2269     completion_cron_mark_started();
2271     completion_cron_criteria();
2273     completion_cron_completions();
2276 /**
2277  * Returns an ordered array of tags associated with visible courses
2278  * (boosted replacement of get_all_tags() allowing association with user and tagtype).
2279  *
2280  * @deprecated since 3.0
2281  * @package  core_tag
2282  * @category tag
2283  * @param    int      $courseid A course id. Passing 0 will return all distinct tags for all visible courses
2284  * @param    int      $userid   (optional) the user id, a default of 0 will return all users tags for the course
2285  * @param    string   $tagtype  (optional) The type of tag, empty string returns all types. Currently (Moodle 2.2) there are two
2286  *                              types of tags which are used within Moodle, they are 'official' and 'default'.
2287  * @param    int      $numtags  (optional) number of tags to display, default of 80 is set in the block, 0 returns all
2288  * @param    string   $unused   (optional) was selected sorting, moved to tag_print_cloud()
2289  * @return   array
2290  */
2291 function coursetag_get_tags($courseid, $userid=0, $tagtype='', $numtags=0, $unused = '') {
2292     debugging('Function coursetag_get_tags() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2294     global $CFG, $DB;
2296     // get visible course ids
2297     $courselist = array();
2298     if ($courseid === 0) {
2299         if ($courses = $DB->get_records_select('course', 'visible=1 AND category>0', null, '', 'id')) {
2300             foreach ($courses as $key => $value) {
2301                 $courselist[] = $key;
2302             }
2303         }
2304     }
2306     // get tags from the db ordered by highest count first
2307     $params = array();
2308     $sql = "SELECT id as tkey, name, id, isstandard, rawname, f.timemodified, flag, count
2309               FROM {tag} t,
2310                  (SELECT tagid, MAX(timemodified) as timemodified, COUNT(id) as count
2311                     FROM {tag_instance}
2312                    WHERE itemtype = 'course' ";
2314     if ($courseid > 0) {
2315         $sql .= "    AND itemid = :courseid ";
2316         $params['courseid'] = $courseid;
2317     } else {
2318         if (!empty($courselist)) {
2319             list($usql, $uparams) = $DB->get_in_or_equal($courselist, SQL_PARAMS_NAMED);
2320             $sql .= "AND itemid $usql ";
2321             $params = $params + $uparams;
2322         }
2323     }
2325     if ($userid > 0) {
2326         $sql .= "    AND tiuserid = :userid ";
2327         $params['userid'] = $userid;
2328     }
2330     $sql .= "   GROUP BY tagid) f
2331              WHERE t.id = f.tagid ";
2332     if ($tagtype != '') {
2333         $sql .= "AND isstandard = :isstandard ";
2334         $params['isstandard'] = ($tagtype === 'official') ? 1 : 0;
2335     }
2336     $sql .= "ORDER BY count DESC, name ASC";
2338     // limit the number of tags for output
2339     if ($numtags == 0) {
2340         $tags = $DB->get_records_sql($sql, $params);
2341     } else {
2342         $tags = $DB->get_records_sql($sql, $params, 0, $numtags);
2343     }
2345     // prepare the return
2346     $return = array();
2347     if ($tags) {
2348         // avoid print_tag_cloud()'s ksort upsetting ordering by setting the key here
2349         foreach ($tags as $value) {
2350             $return[] = $value;
2351         }
2352     }
2354     return $return;
2358 /**
2359  * Returns an ordered array of tags
2360  * (replaces popular_tags_count() allowing sorting).
2361  *
2362  * @deprecated since 3.0
2363  * @package  core_tag
2364  * @category tag
2365  * @param    string $unused (optional) was selected sorting - moved to tag_print_cloud()
2366  * @param    int    $numtags (optional) number of tags to display, default of 20 is set in the block, 0 returns all
2367  * @return   array
2368  */
2369 function coursetag_get_all_tags($unused='', $numtags=0) {
2370     debugging('Function coursetag_get_all_tag() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2372     global $CFG, $DB;
2374     // note that this selects all tags except for courses that are not visible
2375     $sql = "SELECT id, name, isstandard, rawname, f.timemodified, flag, count
2376         FROM {tag} t,
2377         (SELECT tagid, MAX(timemodified) as timemodified, COUNT(id) as count
2378             FROM {tag_instance} WHERE tagid NOT IN
2379                 (SELECT tagid FROM {tag_instance} ti, {course} c
2380                 WHERE c.visible = 0
2381                 AND ti.itemtype = 'course'
2382                 AND ti.itemid = c.id)
2383         GROUP BY tagid) f
2384         WHERE t.id = f.tagid
2385         ORDER BY count DESC, name ASC";
2386     if ($numtags == 0) {
2387         $tags = $DB->get_records_sql($sql);
2388     } else {
2389         $tags = $DB->get_records_sql($sql, null, 0, $numtags);
2390     }
2392     $return = array();
2393     if ($tags) {
2394         foreach ($tags as $value) {
2395             $return[] = $value;
2396         }
2397     }
2399     return $return;
2402 /**
2403  * Returns javascript for use in tags block and supporting pages
2404  *
2405  * @deprecated since 3.0
2406  * @package  core_tag
2407  * @category tag
2408  * @return   null
2409  */
2410 function coursetag_get_jscript() {
2411     debugging('Function coursetag_get_jscript() is deprecated and obsolete.', DEBUG_DEVELOPER);
2412     return '';
2415 /**
2416  * Returns javascript to create the links in the tag block footer.
2417  *
2418  * @deprecated since 3.0
2419  * @package  core_tag
2420  * @category tag
2421  * @param    string   $elementid       the element to attach the footer to
2422  * @param    array    $coursetagslinks links arrays each consisting of 'title', 'onclick' and 'text' elements
2423  * @return   string   always returns a blank string
2424  */
2425 function coursetag_get_jscript_links($elementid, $coursetagslinks) {
2426     debugging('Function coursetag_get_jscript_links() is deprecated and obsolete.', DEBUG_DEVELOPER);
2427     return '';
2430 /**
2431  * Returns all tags created by a user for a course
2432  *
2433  * @deprecated since 3.0
2434  * @package  core_tag
2435  * @category tag
2436  * @param    int      $courseid tags are returned for the course that has this courseid
2437  * @param    int      $userid   return tags which were created by this user
2438  */
2439 function coursetag_get_records($courseid, $userid) {
2440     debugging('Function coursetag_get_records() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2442     global $CFG, $DB;
2444     $sql = "SELECT t.id, name, rawname
2445               FROM {tag} t, {tag_instance} ti
2446              WHERE t.id = ti.tagid
2447                  AND ti.tiuserid = :userid
2448                  AND ti.itemid = :courseid
2449           ORDER BY name ASC";
2451     return $DB->get_records_sql($sql, array('userid'=>$userid, 'courseid'=>$courseid));
2454 /**
2455  * Stores a tag for a course for a user
2456  *
2457  * @deprecated since 3.0
2458  * @package  core_tag
2459  * @category tag
2460  * @param    array  $tags     simple array of keywords to be stored
2461  * @param    int    $courseid the id of the course we wish to store a tag for
2462  * @param    int    $userid   the id of the user we wish to store a tag for
2463  * @param    string $tagtype  official or default only
2464  * @param    string $myurl    (optional) for logging creation of course tags
2465  */
2466 function coursetag_store_keywords($tags, $courseid, $userid=0, $tagtype='official', $myurl='') {
2467     debugging('Function coursetag_store_keywords() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2469     global $CFG;
2471     if (is_array($tags) and !empty($tags)) {
2472         if ($tagtype === 'official') {
2473             $tagcoll = core_tag_area::get_collection('core', 'course');
2474             // We don't normally need to create tags, they are created automatically when added to items. but we do here because we want them to be official.
2475             core_tag_tag::create_if_missing($tagcoll, $tags, true);
2476         }
2477         foreach ($tags as $tag) {
2478             $tag = trim($tag);
2479             if (strlen($tag) > 0) {
2480                 core_tag_tag::add_item_tag('core', 'course', $courseid, context_course::instance($courseid), $tag, $userid);
2481             }
2482         }
2483     }
2487 /**
2488  * Deletes a personal tag for a user for a course.
2489  *
2490  * @deprecated since 3.0
2491  * @package  core_tag
2492  * @category tag
2493  * @param    int      $tagid    the tag we wish to delete
2494  * @param    int      $userid   the user that the tag is associated with
2495  * @param    int      $courseid the course that the tag is associated with
2496  */
2497 function coursetag_delete_keyword($tagid, $userid, $courseid) {
2498     debugging('Function coursetag_delete_keyword() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2500     $tag = core_tag_tag::get($tagid);
2501     core_tag_tag::remove_item_tag('core', 'course', $courseid, $tag->rawname, $userid);
2504 /**
2505  * Get courses tagged with a tag
2506  *
2507  * @deprecated since 3.0
2508  * @package  core_tag
2509  * @category tag
2510  * @param int $tagid
2511  * @return array of course objects
2512  */
2513 function coursetag_get_tagged_courses($tagid) {
2514     debugging('Function coursetag_get_tagged_courses() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER);
2516     global $DB;
2518     $courses = array();
2520     $ctxselect = context_helper::get_preload_record_columns_sql('ctx');
2522     $sql = "SELECT c.*, $ctxselect
2523             FROM {course} c
2524             JOIN {tag_instance} t ON t.itemid = c.id
2525             JOIN {context} ctx ON ctx.instanceid = c.id
2526             WHERE t.tagid = :tagid AND
2527             t.itemtype = 'course' AND
2528             ctx.contextlevel = :contextlevel
2529             ORDER BY c.sortorder ASC";
2530     $params = array('tagid' => $tagid, 'contextlevel' => CONTEXT_COURSE);
2531     $rs = $DB->get_recordset_sql($sql, $params);
2532     foreach ($rs as $course) {
2533         context_helper::preload_from_record($course);
2534         if ($course->visible == 1 || has_capability('moodle/course:viewhiddencourses', context_course::instance($course->id))) {
2535             $courses[$course->id] = $course;
2536         }
2537     }
2538     return $courses;
2541 /**
2542  * Course tagging function used only during the deletion of a course (called by lib/moodlelib.php) to clean up associated tags
2543  *
2544  * @package core_tag
2545  * @deprecated since 3.0
2546  * @param   int      $courseid     the course we wish to delete tag instances from
2547  * @param   bool     $showfeedback if we should output a notification of the delete to the end user
2548  */
2549 function coursetag_delete_course_tags($courseid, $showfeedback=false) {
2550     debugging('Function coursetag_delete_course_tags() is deprecated. Use core_tag_tag::remove_all_item_tags().', DEBUG_DEVELOPER);
2552     global $OUTPUT;
2553     core_tag_tag::remove_all_item_tags('core', 'course', $courseid);
2555     if ($showfeedback) {
2556         echo $OUTPUT->notification(get_string('deletedcoursetags', 'tag'), 'notifysuccess');
2557     }
2560 /**
2561  * Set the type of a tag.  At this time (version 2.2) the possible values are 'default' or 'official'.  Official tags will be
2562  * displayed separately "at tagging time" (while selecting the tags to apply to a record).
2563  *
2564  * @package  core_tag
2565  * @deprecated since 3.1
2566  * @param    string   $tagid tagid to modify
2567  * @param    string   $type either 'default' or 'official'
2568  * @return   bool     true on success, false otherwise
2569  */
2570 function tag_type_set($tagid, $type) {
2571     debugging('Function tag_type_set() is deprecated and can be replaced with use core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER);
2572     if ($tag = core_tag_tag::get($tagid, '*')) {
2573         return $tag->update(array('isstandard' => ($type === 'official') ? 1 : 0));
2574     }
2575     return false;
2578 /**
2579  * Set the description of a tag
2580  *
2581  * @package  core_tag
2582  * @deprecated since 3.1
2583  * @param    int      $tagid the id of the tag
2584  * @param    string   $description the tag's description string to be set
2585  * @param    int      $descriptionformat the moodle text format of the description
2586  *                    {@link http://docs.moodle.org/dev/Text_formats_2.0#Database_structure}
2587  * @return   bool     true on success, false otherwise
2588  */
2589 function tag_description_set($tagid, $description, $descriptionformat) {
2590     debugging('Function tag_type_set() is deprecated and can be replaced with core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER);
2591     if ($tag = core_tag_tag::get($tagid, '*')) {
2592         return $tag->update(array('description' => $description, 'descriptionformat' => $descriptionformat));
2593     }
2594     return false;
2597 /**
2598  * Get the array of db record of tags associated to a record (instances).
2599  *
2600  * @package core_tag
2601  * @deprecated since 3.1
2602  * @param string $record_type the record type for which we want to get the tags
2603  * @param int $record_id the record id for which we want to get the tags
2604  * @param string $type the tag type (either 'default' or 'official'). By default, all tags are returned.
2605  * @param int $userid (optional) only required for course tagging
2606  * @return array the array of tags
2607  */
2608 function tag_get_tags($record_type, $record_id, $type=null, $userid=0) {
2609     debugging('Method tag_get_tags() is deprecated and replaced with core_tag_tag::get_item_tags(). ' .
2610         'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER);
2611     $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY :
2612         (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT));
2613     $tags = core_tag_tag::get_item_tags(null, $record_type, $record_id, $standardonly, $userid);
2614     $rv = array();
2615     foreach ($tags as $id => $t) {
2616         $rv[$id] = $t->to_object();
2617     }
2618     return $rv;
2621 /**
2622  * Get the array of tags display names, indexed by id.
2623  *
2624  * @package  core_tag
2625  * @deprecated since 3.1
2626  * @param    string $record_type the record type for which we want to get the tags
2627  * @param    int    $record_id   the record id for which we want to get the tags
2628  * @param    string $type        the tag type (either 'default' or 'official'). By default, all tags are returned.
2629  * @return   array  the array of tags (with the value returned by core_tag_tag::make_display_name), indexed by id
2630  */
2631 function tag_get_tags_array($record_type, $record_id, $type=null) {
2632     debugging('Method tag_get_tags_array() is deprecated and replaced with core_tag_tag::get_item_tags_array(). ' .
2633         'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER);
2634     $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY :
2635         (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT));
2636     return core_tag_tag::get_item_tags_array('', $record_type, $record_id, $standardonly);
2639 /**
2640  * Get a comma-separated string of tags associated to a record.
2641  *
2642  * Use {@link tag_get_tags()} to get the same information in an array.
2643  *
2644  * @package  core_tag
2645  * @deprecated since 3.1
2646  * @param    string   $record_type the record type for which we want to get the tags
2647  * @param    int      $record_id   the record id for which we want to get the tags
2648  * @param    int      $html        either TAG_RETURN_HTML or TAG_RETURN_TEXT, depending on the type of output desired
2649  * @param    string   $type        either 'official' or 'default', if null, all tags are returned
2650  * @return   string   the comma-separated list of tags.
2651  */
2652 function tag_get_tags_csv($record_type, $record_id, $html=null, $type=null) {
2653     global $CFG, $OUTPUT;
2654     debugging('Method tag_get_tags_csv() is deprecated. Instead you should use either ' .
2655             'core_tag_tag::get_item_tags_array() or $OUTPUT->tag_list(core_tag_tag::get_item_tags()). ' .
2656         'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER);
2657     $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY :
2658         (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT));
2659     if ($html != TAG_RETURN_TEXT) {
2660         return $OUTPUT->tag_list(core_tag_tag::get_item_tags('', $record_type, $record_id, $standardonly), '');
2661     } else {
2662         return join(', ', core_tag_tag::get_item_tags_array('', $record_type, $record_id, $standardonly, 0, false));
2663     }
2666 /**
2667  * Get an array of tag ids associated to a record.
2668  *
2669  * @package  core_tag
2670  * @deprecated since 3.1
2671  * @param    string    $record_type the record type for which we want to get the tags
2672  * @param    int       $record_id the record id for which we want to get the tags
2673  * @return   array     tag ids, indexed and sorted by 'ordering'
2674  */
2675 function tag_get_tags_ids($record_type, $record_id) {
2676     debugging('Method tag_get_tags_ids() is deprecated. Please consider using core_tag_tag::get_item_tags() or similar methods.', DEBUG_DEVELOPER);
2677     $tag_ids = array();
2678     $tagobjects = core_tag_tag::get_item_tags(null, $record_type, $record_id);
2679     foreach ($tagobjects as $tagobject) {
2680         $tag = $tagobject->to_object();
2681         if ( array_key_exists($tag->ordering, $tag_ids) ) {
2682             $tag->ordering++;
2683         }
2684         $tag_ids[$tag->ordering] = $tag->id;
2685     }
2686     ksort($tag_ids);
2687     return $tag_ids;
2690 /**
2691  * Returns the database ID of a set of tags.
2692  *
2693  * @deprecated since 3.1
2694  * @param    mixed $tags one tag, or array of tags, to look for.
2695  * @param    bool  $return_value specify the type of the returned value. Either TAG_RETURN_OBJECT, or TAG_RETURN_ARRAY (default).
2696  *                               If TAG_RETURN_ARRAY is specified, an array will be returned even if only one tag was passed in $tags.
2697  * @return   mixed tag-indexed array of ids (or objects, if second parameter is TAG_RETURN_OBJECT), or only an int, if only one tag
2698  *                 is given *and* the second parameter is null. No value for a key means the tag wasn't found.
2699  */
2700 function tag_get_id($tags, $return_value = null) {
2701     global $CFG, $DB;
2702     debugging('Method tag_get_id() is deprecated and can be replaced with core_tag_tag::get_by_name() or core_tag_tag::get_by_name_bulk(). ' .
2703         'You need to specify tag collection when retrieving tag by name', DEBUG_DEVELOPER);
2705     if (!is_array($tags)) {
2706         if(is_null($return_value) || $return_value == TAG_RETURN_OBJECT) {
2707             if ($tagobject = core_tag_tag::get_by_name(core_tag_collection::get_default(), $tags)) {
2708                 return $tagobject->id;
2709             } else {
2710                 return 0;
2711             }
2712         }
2713         $tags = array($tags);
2714     }
2716     $records = core_tag_tag::get_by_name_bulk(core_tag_collection::get_default(), $tags,
2717         $return_value == TAG_RETURN_OBJECT ? '*' : 'id, name');
2718     foreach ($records as $name => $record) {
2719         if ($return_value != TAG_RETURN_OBJECT) {
2720             $records[$name] = $record->id ? $record->id : null;
2721         } else {
2722             $records[$name] = $record->to_object();
2723         }
2724     }
2725     return $records;
2728 /**
2729  * Change the "value" of a tag, and update the associated 'name'.
2730  *
2731  * @package  core_tag
2732  * @deprecated since 3.1
2733  * @param    int      $tagid  the id of the tag to modify
2734  * @param    string   $newrawname the new rawname
2735  * @return   bool     true on success, false otherwise
2736  */
2737 function tag_rename($tagid, $newrawname) {
2738     debugging('Function tag_rename() is deprecated and may be replaced with core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER);
2739     if ($tag = core_tag_tag::get($tagid, '*')) {
2740         return $tag->update(array('rawname' => $newrawname));
2741     }
2742     return false;
2745 /**
2746  * Delete one instance of a tag.  If the last instance was deleted, it will also delete the tag, unless its type is 'official'.
2747  *
2748  * @package  core_tag
2749  * @deprecated since 3.1
2750  * @param    string $record_type the type of the record for which to remove the instance
2751  * @param    int    $record_id   the id of the record for which to remove the instance
2752  * @param    int    $tagid       the tagid that needs to be removed
2753  * @param    int    $userid      (optional) the userid
2754  * @return   bool   true on success, false otherwise
2755  */
2756 function tag_delete_instance($record_type, $record_id, $tagid, $userid = null) {
2757     debugging('Function tag_delete_instance() is deprecated and replaced with core_tag_tag::remove_item_tag() instead. ' .
2758         'Component is required for retrieving instances', DEBUG_DEVELOPER);
2759     $tag = core_tag_tag::get($tagid);
2760     core_tag_tag::remove_item_tag('', $record_type, $record_id, $tag->rawname, $userid);
2763 /**
2764  * Find all records tagged with a tag of a given type ('post', 'user', etc.)
2765  *
2766  * @package  core_tag
2767  * @deprecated since 3.1
2768  * @category tag
2769  * @param    string   $tag       tag to look for
2770  * @param    string   $type      type to restrict search to.  If null, every matching record will be returned
2771  * @param    int      $limitfrom (optional, required if $limitnum is set) return a subset of records, starting at this point.
2772  * @param    int      $limitnum  (optional, required if $limitfrom is set) return a subset comprising this many records.
2773  * @return   array of matching objects, indexed by record id, from the table containing the type requested
2774  */
2775 function tag_find_records($tag, $type, $limitfrom='', $limitnum='') {
2776     debugging('Function tag_find_records() is deprecated and replaced with core_tag_tag::get_by_name()->get_tagged_items(). '.
2777         'You need to specify tag collection when retrieving tag by name', DEBUG_DEVELOPER);
2779     if (!$tag || !$type) {
2780         return array();
2781     }
2783     $tagobject = core_tag_tag::get_by_name(core_tag_area::get_collection('', $type), $tag);
2784     return $tagobject->get_tagged_items('', $type, $limitfrom, $limitnum);
2787 /**
2788  * Adds one or more tag in the database.  This function should not be called directly : you should
2789  * use tag_set.
2790  *
2791  * @package core_tag
2792  * @deprecated since 3.1
2793  * @param   mixed    $tags     one tag, or an array of tags, to be created
2794  * @param   string   $type     type of tag to be created ("default" is the default value and "official" is the only other supported
2795  *                             value at this time). An official tag is kept even if there are no records tagged with it.
2796  * @return array     $tags ids indexed by their lowercase normalized names. Any boolean false in the array indicates an error while
2797  *                             adding the tag.
2798  */
2799 function tag_add($tags, $type="default") {
2800     debugging('Function tag_add() is deprecated. You can use core_tag_tag::create_if_missing(), however it should not be necessary ' .
2801         'since tags are created automatically when assigned to items', DEBUG_DEVELOPER);
2802     if (!is_array($tags)) {
2803         $tags = array($tags);
2804     }
2805     $objects = core_tag_tag::create_if_missing(core_tag_collection::get_default(), $tags,
2806             $type === 'official');
2808     // New function returns the tags in different format, for BC we keep the format that this function used to have.
2809     $rv = array();
2810     foreach ($objects as $name => $tagobject) {
2811         if (isset($tagobject->id)) {
2812             $rv[$tagobject->name] = $tagobject->id;
2813         } else {
2814             $rv[$name] = false;
2815         }
2816     }
2817     return $rv;
2820 /**
2821  * Assigns a tag to a record; if the record already exists, the time and ordering will be updated.
2822  *
2823  * @package core_tag
2824  * @deprecated since 3.1
2825  * @param string $record_type the type of the record that will be tagged
2826  * @param int $record_id the id of the record that will be tagged
2827  * @param string $tagid the tag id to set on the record.
2828  * @param int $ordering the order of the instance for this record
2829  * @param int $userid (optional) only required for course tagging
2830  * @param string|null $component the component that was tagged
2831  * @param int|null $contextid the context id of where this tag was assigned
2832  * @return bool true on success, false otherwise
2833  */
2834 function tag_assign($record_type, $record_id, $tagid, $ordering, $userid = 0, $component = null, $contextid = null) {
2835     global $DB;
2836     $message = 'Function tag_assign() is deprecated. Use core_tag_tag::set_item_tags() or core_tag_tag::add_item_tag() instead. ' .
2837         'Tag instance ordering should not be set manually';
2838     if ($component === null || $contextid === null) {
2839         $message .= '. You should specify the component and contextid of the item being tagged in your call to tag_assign.';
2840     }
2841     debugging($message, DEBUG_DEVELOPER);
2843     if ($contextid) {
2844         $context = context::instance_by_id($contextid);
2845     } else {
2846         $context = context_system::instance();
2847     }
2849     // Get the tag.
2850     $tag = $DB->get_record('tag', array('id' => $tagid), 'name, rawname', MUST_EXIST);
2852     $taginstanceid = core_tag_tag::add_item_tag($component, $record_type, $record_id, $context, $tag->rawname, $userid);
2854     // Alter the "ordering" of tag_instance. This should never be done manually and only remains here for the backward compatibility.
2855     $taginstance = new stdClass();
2856     $taginstance->id = $taginstanceid;
2857     $taginstance->ordering     = $ordering;
2858     $taginstance->timemodified = time();
2860     $DB->update_record('tag_instance', $taginstance);
2862     return true;
2865 /**
2866  * Count how many records are tagged with a specific tag.
2867  *
2868  * @package core_tag
2869  * @deprecated since 3.1
2870  * @param   string   $record_type record to look for ('post', 'user', etc.)
2871  * @param   int      $tagid       is a single tag id
2872  * @return  int      number of mathing tags.
2873  */
2874 function tag_record_count($record_type, $tagid) {
2875     debugging('Method tag_record_count() is deprecated and replaced with core_tag_tag::get($tagid)->count_tagged_items(). '.
2876         'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER);
2877     return core_tag_tag::get($tagid)->count_tagged_items('', $record_type);
2880 /**
2881  * Determine if a record is tagged with a specific tag
2882  *
2883  * @package core_tag
2884  * @deprecated since 3.1
2885  * @param   string   $record_type the record type to look for
2886  * @param   int      $record_id   the record id to look for
2887  * @param   string   $tag         a tag name
2888  * @return  bool/int true if it is tagged, 0 (false) otherwise
2889  */
2890 function tag_record_tagged_with($record_type, $record_id, $tag) {
2891     debugging('Method tag_record_tagged_with() is deprecated and replaced with core_tag_tag::get($tagid)->is_item_tagged_with(). '.
2892         'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER);
2893     return core_tag_tag::is_item_tagged_with('', $record_type, $record_id, $tag);
2896 /**
2897  * Flag a tag as inappropriate.
2898  *
2899  * @deprecated since 3.1
2900  * @param int|array $tagids a single tagid, or an array of tagids
2901  */
2902 function tag_set_flag($tagids) {
2903     debugging('Function tag_set_flag() is deprecated and replaced with core_tag_tag::get($tagid)->flag().', DEBUG_DEVELOPER);
2904     $tagids = (array) $tagids;
2905     foreach ($tagids as $tagid) {
2906         if ($tag = core_tag_tag::get($tagid, '*')) {
2907             $tag->flag();
2908         }
2909     }
2912 /**
2913  * Remove the inappropriate flag on a tag.
2914  *
2915  * @deprecated since 3.1
2916  * @param int|array $tagids a single tagid, or an array of tagids
2917  */
2918 function tag_unset_flag($tagids) {
2919     debugging('Function tag_unset_flag() is deprecated and replaced with core_tag_tag::get($tagid)->reset_flag().', DEBUG_DEVELOPER);
2920     $tagids = (array) $tagids;
2921     foreach ($tagids as $tagid) {
2922         if ($tag = core_tag_tag::get($tagid, '*')) {
2923             $tag->reset_flag();
2924         }
2925     }
2928 /**
2929  * Prints or returns a HTML tag cloud with varying classes styles depending on the popularity and type of each tag.
2930  *
2931  * @deprecated since 3.1
2932  *
2933  * @param    array     $tagset Array of tags to display
2934  * @param    int       $nr_of_tags Limit for the number of tags to return/display, used if $tagset is null
2935  * @param    bool      $return     if true the function will return the generated tag cloud instead of displaying it.
2936  * @param    string    $sort (optional) selected sorting, default is alpha sort (name) also timemodified or popularity
2937  * @return string|null a HTML string or null if this function does the output
2938  */
2939 function tag_print_cloud($tagset=null, $nr_of_tags=150, $return=false, $sort='') {
2940     global $OUTPUT;
2942     debugging('Function tag_print_cloud() is deprecated and replaced with function core_tag_collection::get_tag_cloud(), '
2943             . 'templateable core_tag\output\tagcloud and template core_tag/tagcloud.', DEBUG_DEVELOPER);
2945     // Set up sort global - used to pass sort type into core_tag_collection::cloud_sort through usort() avoiding multiple sort functions.
2946     if ($sort == 'popularity') {
2947         $sort = 'count';
2948     } else if ($sort == 'date') {
2949         $sort = 'timemodified';
2950     } else {
2951         $sort = 'name';
2952     }
2954     if (is_null($tagset)) {
2955         // No tag set received, so fetch tags from database.
2956         // Always add query by tagcollid even when it's not known to make use of the table index.
2957         $tagcloud = core_tag_collection::get_tag_cloud(0, false, $nr_of_tags, $sort);
2958     } else {
2959         $tagsincloud = $tagset;
2961         $etags = array();
2962         foreach ($tagsincloud as $tag) {
2963             $etags[] = $tag;
2964         }
2966         core_tag_collection::$cloudsortfield = $sort;
2967         usort($tagsincloud, "core_tag_collection::cloud_sort");
2969         $tagcloud = new \core_tag\output\tagcloud($tagsincloud);
2970     }
2972     $output = $OUTPUT->render_from_template('core_tag/tagcloud', $tagcloud->export_for_template($OUTPUT));
2973     if ($return) {
2974         return $output;
2975     } else {
2976         echo $output;
2977     }
2980 /**
2981  * Function that returns tags that start with some text, for use by the autocomplete feature
2982  *
2983  * @package core_tag
2984  * @deprecated since 3.0
2985  * @access  private
2986  * @param   string   $text string that the tag names will be matched against
2987  * @return  mixed    an array of objects, or false if no records were found or an error occured.
2988  */
2989 function tag_autocomplete($text) {
2990     debugging('Function tag_autocomplete() is deprecated without replacement. ' .
2991             'New form element "tags" does proper autocomplete.', DEBUG_DEVELOPER);
2992     global $DB;
2993     return $DB->get_records_sql("SELECT tg.id, tg.name, tg.rawname
2994                                    FROM {tag} tg
2995                                   WHERE tg.name LIKE ?", array(core_text::strtolower($text)."%"));
2998 /**
2999  * Prints a box with the description of a tag and its related tags
3000  *
3001  * @package core_tag
3002  * @deprecated since 3.1
3003  * @param   stdClass    $tag_object
3004  * @param   bool        $return     if true the function will return the generated tag cloud instead of displaying it.
3005  * @return  string/null a HTML box showing a description of the tag object and it's relationsips or null if output is done directly
3006  *                      in the function.
3007  */
3008 function tag_print_description_box($tag_object, $return=false) {
3009     global $USER, $CFG, $OUTPUT;
3010     require_once($CFG->libdir.'/filelib.php');
3012     debugging('Function tag_print_description_box() is deprecated without replacement. ' .
3013             'See core_tag_renderer for similar code.', DEBUG_DEVELOPER);
3015     $relatedtags = array();
3016     if ($tag = core_tag_tag::get($tag_object->id)) {
3017         $relatedtags = $tag->get_related_tags();
3018     }
3020     $content = !empty($tag_object->description);
3021     $output = '';
3023     if ($content) {
3024         $output .= $OUTPUT->box_start('generalbox tag-description');
3025     }
3027     if (!empty($tag_object->description)) {
3028         $options = new stdClass();
3029         $options->para = false;
3030         $options->overflowdiv = true;
3031         $tag_object->description = file_rewrite_pluginfile_urls($tag_object->description, 'pluginfile.php', context_system::instance()->id, 'tag', 'description', $tag_object->id);
3032         $output .= format_text($tag_object->description, $tag_object->descriptionformat, $options);
3033     }
3035     if ($content) {
3036         $output .= $OUTPUT->box_end();
3037     }
3039     if ($relatedtags) {
3040         $output .= $OUTPUT->tag_list($relatedtags, get_string('relatedtags', 'tag'), 'tag-relatedtags');
3041     }
3043     if ($return) {
3044         return $output;
3045     } else {
3046         echo $output;
3047     }
3050 /**
3051  * Prints a box that contains the management links of a tag
3052  *
3053  * @deprecated since 3.1
3054  * @param  core_tag_tag|stdClass    $tag_object
3055  * @param  bool        $return     if true the function will return the generated tag cloud instead of displaying it.
3056  * @return string|null a HTML string or null if this function does the output
3057  */
3058 function tag_print_management_box($tag_object, $return=false) {
3059     global $USER, $CFG, $OUTPUT;
3061     debugging('Function tag_print_description_box() is deprecated without replacement. ' .
3062             'See core_tag_renderer for similar code.', DEBUG_DEVELOPER);
3064     $tagname  = core_tag_tag::make_display_name($tag_object);
3065     $output = '';
3067     if (!isguestuser()) {
3068         $output .= $OUTPUT->box_start('box','tag-management-box');
3069         $systemcontext   = context_system::instance();
3070         $links = array();
3072         // Add a link for users to add/remove this from their interests
3073         if (core_tag_tag::is_enabled('core', 'user') && core_tag_area::get_collection('core', 'user') == $tag_object->tagcollid) {
3074             if (core_tag_tag::is_item_tagged_with('core', 'user', $USER->id, $tag_object->name)) {
3075                 $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=removeinterest&amp;sesskey='. sesskey() .
3076                         '&amp;tag='. rawurlencode($tag_object->name) .'">'.
3077                         get_string('removetagfrommyinterests', 'tag', $tagname) .'</a>';
3078             } else {
3079                 $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=addinterest&amp;sesskey='. sesskey() .
3080                         '&amp;tag='. rawurlencode($tag_object->name) .'">'.
3081                         get_string('addtagtomyinterests', 'tag', $tagname) .'</a>';
3082             }
3083         }
3085         // Flag as inappropriate link.  Only people with moodle/tag:flag capability.
3086         if (has_capability('moodle/tag:flag', $systemcontext)) {
3087             $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=flaginappropriate&amp;sesskey='.
3088                     sesskey() . '&amp;id='. $tag_object->id . '">'. get_string('flagasinappropriate',
3089                             'tag', rawurlencode($tagname)) .'</a>';
3090         }
3092         // Edit tag: Only people with moodle/tag:edit capability who either have it as an interest or can manage tags
3093         if (has_capability('moodle/tag:edit', $systemcontext) ||
3094             has_capability('moodle/tag:manage', $systemcontext)) {
3095             $links[] = '<a href="' . $CFG->wwwroot . '/tag/edit.php?id=' . $tag_object->id . '">' .
3096                     get_string('edittag', 'tag') . '</a>';
3097         }
3099         $output .= implode(' | ', $links);
3100         $output .= $OUTPUT->box_end();
3101     }
3103     if ($return) {
3104         return $output;
3105     } else {
3106         echo $output;
3107     }
3110 /**
3111  * Prints the tag search box
3112  *
3113  * @deprecated since 3.1
3114  * @param  bool        $return if true return html string
3115  * @return string|null a HTML string or null if this function does the output
3116  */
3117 function tag_print_search_box($return=false) {
3118     global $CFG, $OUTPUT;
3120     debugging('Function tag_print_search_box() is deprecated without replacement. ' .
3121             'See core_tag_renderer for similar code.', DEBUG_DEVELOPER);
3123     $query = optional_param('query', '', PARAM_RAW);
3125     $output = $OUTPUT->box_start('','tag-search-box');
3126     $output .= '<form action="'.$CFG->wwwroot.'/tag/search.php" style="display:inline">';
3127     $output .= '<div>';
3128     $output .= '<label class="accesshide" for="searchform_search">'.get_string('searchtags', 'tag').'</label>';
3129     $output .= '<input id="searchform_search" name="query" type="text" size="40" value="'.s($query).'" />';
3130     $output .= '<button id="searchform_button" type="submit">'. get_string('search', 'tag') .'</button><br />';
3131     $output .= '</div>';
3132     $output .= '</form>';
3133     $output .= $OUTPUT->box_end();
3135     if ($return) {
3136         return $output;
3137     }
3138     else {
3139         echo $output;
3140     }
3143 /**
3144  * Prints the tag search results
3145  *
3146  * @deprecated since 3.1
3147  * @param string       $query text that tag names will be matched against
3148  * @param int          $page current page
3149  * @param int          $perpage nr of users displayed per page
3150  * @param bool         $return if true return html string
3151  * @return string|null a HTML string or null if this function does the output
3152  */
3153 function tag_print_search_results($query,  $page, $perpage, $return=false) {
3154     global $CFG, $USER, $OUTPUT;
3156     debugging('Function tag_print_search_results() is deprecated without replacement. ' .
3157             'In /tag/search.php the search results are printed using the core_tag/tagcloud template.', DEBUG_DEVELOPER);
3159     $query = clean_param($query, PARAM_TAG);
3161     $count = count(tag_find_tags($query, false));
3162     $tags = array();
3164     if ( $found_tags = tag_find_tags($query, true,  $page * $perpage, $perpage) ) {
3165         $tags = array_values($found_tags);
3166     }
3168     $baseurl = $CFG->wwwroot.'/tag/search.php?query='. rawurlencode($query);
3169     $output = '';
3171     // link "Add $query to my interests"
3172     $addtaglink = '';
3173     if (core_tag_tag::is_enabled('core', 'user') && !core_tag_tag::is_item_tagged_with('core', 'user', $USER->id, $query)) {
3174         $addtaglink = html_writer::link(new moodle_url('/tag/user.php', array('action' => 'addinterest', 'sesskey' => sesskey(),
3175             'tag' => $query)), get_string('addtagtomyinterests', 'tag', s($query)));
3176     }
3178     if ( !empty($tags) ) { // there are results to display!!
3179         $output .= $OUTPUT->heading(get_string('searchresultsfor', 'tag', htmlspecialchars($query)) ." : {$count}", 3, 'main');
3181         //print a link "Add $query to my interests"
3182         if (!empty($addtaglink)) {
3183             $output .= $OUTPUT->box($addtaglink, 'box', 'tag-management-box');
3184         }
3186         $nr_of_lis_per_ul = 6;
3187         $nr_of_uls = ceil( sizeof($tags) / $nr_of_lis_per_ul );
3189         $output .= '<ul id="tag-search-results">';
3190         for($i = 0; $i < $nr_of_uls; $i++) {
3191             foreach (array_slice($tags, $i * $nr_of_lis_per_ul, $nr_of_lis_per_ul) as $tag) {
3192                 $output .= '<li>';
3193                 $tag_link = html_writer::link(core_tag_tag::make_url($tag->tagcollid, $tag->rawname),
3194                     core_tag_tag::make_display_name($tag));
3195                 $output .= $tag_link;
3196                 $output .= '</li>';
3197             }
3198         }
3199         $output .= '</ul>';
3200         $output .= '<div>&nbsp;</div>'; // <-- small layout hack in order to look good in Firefox
3202         $output .= $OUTPUT->paging_bar($count, $page, $perpage, $baseurl);
3203     }
3204     else { //no results were found!!
3205         $output .= $OUTPUT->heading(get_string('noresultsfor', 'tag', htmlspecialchars($query)), 3, 'main');
3207         //print a link "Add $query to my interests"
3208         if (!empty($addtaglink)) {
3209             $output .= $OUTPUT->box($addtaglink, 'box', 'tag-management-box');
3210         }
3211     }
3213     if ($return) {
3214         return $output;
3215     }
3216     else {
3217         echo $output;
3218     }
3221 /**
3222  * Prints a table of the users tagged with the tag passed as argument
3223  *
3224  * @deprecated since 3.1
3225  * @param  stdClass    $tagobject the tag we wish to return data for
3226  * @param  int         $limitfrom (optional, required if $limitnum is set) prints users starting at this point.
3227  * @param  int         $limitnum (optional, required if $limitfrom is set) prints this many users.
3228  * @param  bool        $return if true return html string
3229  * @return string|null a HTML string or null if this function does the output
3230  */
3231 function tag_print_tagged_users_table($tagobject, $limitfrom='', $limitnum='', $return=false) {
3233     debugging('Function tag_print_tagged_users_table() is deprecated without replacement. ' .
3234             'See core_user_renderer for similar code.', DEBUG_DEVELOPER);
3236     //List of users with this tag
3237     $tagobject = core_tag_tag::get($tagobject->id);
3238     $userlist = $tagobject->get_tagged_items('core', 'user', $limitfrom, $limitnum);
3240     $output = tag_print_user_list($userlist, true);
3242     if ($return) {
3243         return $output;
3244     }
3245     else {
3246         echo $output;
3247     }
3250 /**
3251  * Prints an individual user box
3252  *
3253  * @deprecated since 3.1
3254  * @param user_object  $user  (contains the following fields: id, firstname, lastname and picture)
3255  * @param bool         $return if true return html string
3256  * @return string|null a HTML string or null if this function does the output
3257  */
3258 function tag_print_user_box($user, $return=false) {
3259     global $CFG, $OUTPUT;
3261     debugging('Function tag_print_user_box() is deprecated without replacement. ' .
3262             'See core_user_renderer for similar code.', DEBUG_DEVELOPER);
3264     $usercontext = context_user::instance($user->id);
3265     $profilelink = '';
3267     if ($usercontext and (has_capability('moodle/user:viewdetails', $usercontext) || has_coursecontact_role($user->id))) {
3268         $profilelink = $CFG->wwwroot .'/user/view.php?id='. $user->id;
3269     }
3271     $output = $OUTPUT->box_start('user-box', 'user'. $user->id);
3272     $fullname = fullname($user);
3273     $alt = '';
3275     if (!empty($profilelink)) {
3276         $output .= '<a href="'. $profilelink .'">';
3277         $alt = $fullname;
3278     }
3280     $output .= $OUTPUT->user_picture($user, array('size'=>100));
3281     $output .= '<br />';
3283     if (!empty($profilelink)) {
3284         $output .= '</a>';
3285     }
3287     //truncate name if it's too big
3288     if (core_text::strlen($fullname) > 26) {
3289         $fullname = core_text::substr($fullname, 0, 26) .'...';
3290     }
3292     $output .= '<strong>'. $fullname .'</strong>';
3293     $output .= $OUTPUT->box_end();
3295     if ($return) {
3296         return $output;
3297     }
3298     else {
3299         echo $output;
3300     }
3303 /**
3304  * Prints a list of users
3305  *
3306  * @deprecated since 3.1
3307  * @param  array       $userlist an array of user objects
3308  * @param  bool        $return if true return html string, otherwise output the result
3309  * @return string|null a HTML string or null if this function does the output
3310  */
3311 function tag_print_user_list($userlist, $return=false) {
3313     debugging('Function tag_print_user_list() is deprecated without replacement. ' .
3314             'See core_user_renderer for similar code.', DEBUG_DEVELOPER);
3316     $output = '<div><ul class="inline-list">';
3318     foreach ($userlist as $user){
3319         $output .= '<li>'. tag_print_user_box($user, true) ."</li>\n";
3320     }
3321     $output .= "</ul></div>\n";
3323     if ($return) {
3324         return $output;
3325     }
3326     else {
3327         echo $output;
3328     }
3331 /**
3332  * Function that returns the name that should be displayed for a specific tag
3333  *
3334  * @package  core_tag
3335  * @category tag
3336  * @deprecated since 3.1
3337  * @param    stdClass|core_tag_tag   $tagobject a line out of tag table, as returned by the adobd functions
3338  * @param    int      $html TAG_RETURN_HTML (default) will return htmlspecialchars encoded string, TAG_RETURN_TEXT will not encode.
3339  * @return   string
3340  */
3341 function tag_display_name($tagobject, $html=TAG_RETURN_HTML) {
3342     debugging('Function tag_display_name() is deprecated. Use core_tag_tag::make_display_name().', DEBUG_DEVELOPER);
3343     if (!isset($tagobject->name)) {
3344         return '';
3345     }
3346     return core_tag_tag::make_display_name($tagobject, $html != TAG_RETURN_TEXT);
3349 /**
3350  * Function that normalizes a list of tag names.
3351  *
3352  * @package core_tag
3353  * @deprecated since 3.1
3354  * @param   array/string $rawtags array of tags, or a single tag.
3355  * @param   int          $case    case to use for returned value (default: lower case). Either TAG_CASE_LOWER (default) or TAG_CASE_ORIGINAL
3356  * @return  array        lowercased normalized tags, indexed by the normalized tag, in the same order as the original array.
3357  *                       (Eg: 'Banana' => 'banana').
3358  */
3359 function tag_normalize($rawtags, $case = TAG_CASE_LOWER) {
3360     debugging('Function tag_normalize() is deprecated. Use core_tag_tag::normalize().', DEBUG_DEVELOPER);
3362     if ( !is_array($rawtags) ) {
3363         $rawtags = array($rawtags);
3364     }
3366     return core_tag_tag::normalize($rawtags, $case == TAG_CASE_LOWER);
3369 /**
3370  * Get a comma-separated list of tags related to another tag.
3371  *
3372  * @package  core_tag
3373  * @deprecated since 3.1
3374  * @param    array    $related_tags the array returned by tag_get_related_tags
3375  * @param    int      $html    either TAG_RETURN_HTML (default) or TAG_RETURN_TEXT : return html links, or just text.
3376  * @return   string   comma-separated list
3377  */
3378 function tag_get_related_tags_csv($related_tags, $html=TAG_RETURN_HTML) {
3379     global $OUTPUT;
3380     debugging('Method tag_get_related_tags_csv() is deprecated. Consider '
3381             . 'looping through array or using $OUTPUT->tag_list(core_tag_tag::get_item_tags())',
3382         DEBUG_DEVELOPER);
3383     if ($html != TAG_RETURN_TEXT) {
3384         return $OUTPUT->tag_list($related_tags, '');
3385     }
3387     $tagsnames = array();
3388     foreach ($related_tags as $tag) {
3389         $tagsnames[] = core_tag_tag::make_display_name($tag, false);
3390     }
3391     return implode(', ', $tagsnames);
3394 /**
3395  * Used to require that the return value from a function is an array.
3396  * Only used in the deprecated function {@link tag_get_id()}
3397  * @deprecated since 3.1
3398  */
3399 define('TAG_RETURN_ARRAY', 0);
3400 /**
3401  * Used to require that the return value from a function is an object.
3402  * Only used in the deprecated function {@link tag_get_id()}
3403  * @deprecated since 3.1
3404  */
3405 define('TAG_RETURN_OBJECT', 1);
3406 /**
3407  * Use to specify that HTML free text is expected to be returned from a function.
3408  * Only used in deprecated functions {@link tag_get_tags_csv()}, {@link tag_display_name()},
3409  * {@link tag_get_related_tags_csv()}
3410  * @deprecated since 3.1
3411  */
3412 define('TAG_RETURN_TEXT', 2);
3413 /**
3414  * Use to specify that encoded HTML is expected to be returned from a function.
3415  * Only used in deprecated functions {@link tag_get_tags_csv()}, {@link tag_display_name()},
3416  * {@link tag_get_related_tags_csv()}
3417  * @deprecated since 3.1
3418  */
3419 define('TAG_RETURN_HTML', 3);
3421 /**
3422  * Used to specify that we wish a lowercased string to be returned
3423  * Only used in deprecated function {@link tag_normalize()}
3424  * @deprecated since 3.1
3425  */
3426 define('TAG_CASE_LOWER', 0);
3427 /**
3428  * Used to specify that we do not wish the case of the returned string to change
3429  * Only used in deprecated function {@link tag_normalize()}
3430  * @deprecated since 3.1
3431  */
3432 define('TAG_CASE_ORIGINAL', 1);
3434 /**
3435  * Used to specify that we want all related tags returned, no matter how they are related.
3436  * Only used in deprecated function {@link tag_get_related_tags()}
3437  * @deprecated since 3.1
3438  */
3439 define('TAG_RELATED_ALL', 0);
3440 /**
3441  * Used to specify that we only want back tags that were manually related.
3442  * Only used in deprecated function {@link tag_get_related_tags()}
3443  * @deprecated since 3.1
3444  */
3445 define('TAG_RELATED_MANUAL', 1);
3446 /**
3447  * Used to specify that we only want back tags where the relationship was automatically correlated.
3448  * Only used in deprecated function {@link tag_get_related_tags()}
3449  * @deprecated since 3.1
3450  */
3451 define('TAG_RELATED_CORRELATED', 2);
3453 /**
3454  * Set the tags assigned to a record.  This overwrites the current tags.
3455  *
3456  * This function is meant to be fed the string coming up from the user interface, which contains all tags assigned to a record.
3457  *
3458  * Due to API change $component and $contextid are now required. Instead of
3459  * calling  this function you can use {@link core_tag_tag::set_item_tags()} or
3460  * {@link core_tag_tag::set_related_tags()}
3461  *
3462  * @package core_tag
3463  * @deprecated since 3.1
3464  * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, 'tag' for tags, etc.)
3465  * @param int $itemid the id of the record to tag
3466  * @param array $tags the array of tags to set on the record. If given an empty array, all tags will be removed.
3467  * @param string|null $component the component that was tagged
3468  * @param int|null $contextid the context id of where this tag was assigned
3469  * @return bool|null
3470  */
3471 function tag_set($itemtype, $itemid, $tags, $component = null, $contextid = null) {
3472     debugging('Function tag_set() is deprecated. Use ' .
3473         ' core_tag_tag::set_item_tags() instead', DEBUG_DEVELOPER);
3475     if ($itemtype === 'tag') {
3476         return core_tag_tag::get($itemid, '*', MUST_EXIST)->set_related_tags($tags);
3477     } else {
3478         $context = $contextid ? context::instance_by_id($contextid) : context_system::instance();
3479         return core_tag_tag::set_item_tags($component, $itemtype, $itemid, $context, $tags);
3480     }
3483 /**
3484  * Adds a tag to a record, without overwriting the current tags.
3485  *
3486  * This function remains here for backward compatiblity. It is recommended to use
3487  * {@link core_tag_tag::add_item_tag()} or {@link core_tag_tag::add_related_tags()} instead
3488  *
3489  * @package core_tag
3490  * @deprecated since 3.1
3491  * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
3492  * @param int $itemid the id of the record to tag
3493  * @param string $tag the tag to add
3494  * @param string|null $component the component that was tagged
3495  * @param int|null $contextid the context id of where this tag was assigned
3496  * @return bool|null
3497  */
3498 function tag_set_add($itemtype, $itemid, $tag, $component = null, $contextid = null) {
3499     debugging('Function tag_set_add() is deprecated. Use ' .
3500         ' core_tag_tag::add_item_tag() instead', DEBUG_DEVELOPER);
3502     if ($itemtype === 'tag') {
3503         return core_tag_tag::get($itemid, '*', MUST_EXIST)->add_related_tags(array($tag));
3504     } else {
3505         $context = $contextid ? context::instance_by_id($contextid) : context_system::instance();
3506         return core_tag_tag::add_item_tag($component, $itemtype, $itemid, $context, $tag);
3507     }
3510 /**
3511  * Removes a tag from a record, without overwriting other current tags.
3512  *
3513  * This function remains here for backward compatiblity. It is recommended to use
3514  * {@link core_tag_tag::remove_item_tag()} instead
3515  *
3516  * @package core_tag
3517  * @deprecated since 3.1
3518  * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
3519  * @param int $itemid the id of the record to tag
3520  * @param string $tag the tag to delete
3521  * @param string|null $component the component that was tagged
3522  * @param int|null $contextid the context id of where this tag was assigned
3523  * @return bool|null
3524  */
3525 function tag_set_delete($itemtype, $itemid, $tag, $component = null, $contextid = null) {
3526     debugging('Function tag_set_delete() is deprecated. Use ' .
3527         ' core_tag_tag::remove_item_tag() instead', DEBUG_DEVELOPER);
3528     return core_tag_tag::remove_item_tag($component, $itemtype, $itemid, $tag);
3531 /**
3532  * Simple function to just return a single tag object when you know the name or something
3533  *
3534  * See also {@link core_tag_tag::get()} and {@link core_tag_tag::get_by_name()}
3535  *
3536  * @package  core_tag
3537  * @deprecated since 3.1
3538  * @param    string $field        which field do we use to identify the tag: id, name or rawname
3539  * @param    string $value        the required value of the aforementioned field
3540  * @param    string $returnfields which fields do we want returned. This is a comma seperated string containing any combination of
3541  *                                'id', 'name', 'rawname' or '*' to include all fields.
3542  * @return   mixed  tag object
3543  */
3544 function tag_get($field, $value, $returnfields='id, name, rawname, tagcollid') {
3545     global $DB;
3546     debugging('Function tag_get() is deprecated. Use ' .
3547         ' core_tag_tag::get() or core_tag_tag::get_by_name()',
3548         DEBUG_DEVELOPER);
3549     if ($field === 'id') {
3550         $tag = core_tag_tag::get((int)$value, $returnfields);
3551     } else if ($field === 'name') {
3552         $tag = core_tag_tag::get_by_name(0, $value, $returnfields);
3553     } else {
3554         $params = array($field => $value);
3555         return $DB->get_record('tag', $params, $returnfields);
3556     }
3557     if ($tag) {
3558         return $tag->to_object();
3559     }
3560     return null;
3563 /**
3564  * Returns tags related to a tag
3565  *
3566  * Related tags of a tag come from two sources:
3567  *   - manually added related tags, which are tag_instance entries for that tag
3568  *   - correlated tags, which are calculated
3569  *
3570  * @package  core_tag
3571  * @deprecated since 3.1
3572  * @param    string   $tagid          is a single **normalized** tag name or the id of a tag
3573  * @param    int      $type           the function will return either manually (TAG_RELATED_MANUAL) related tags or correlated
3574  *                                    (TAG_RELATED_CORRELATED) tags. Default is TAG_RELATED_ALL, which returns everything.
3575  * @param    int      $limitnum       (optional) return a subset comprising this many records, the default is 10
3576  * @return   array    an array of tag objects
3577  */
3578 function tag_get_related_tags($tagid, $type=TAG_RELATED_ALL, $limitnum=10) {
3579     debugging('Method tag_get_related_tags() is deprecated, '
3580         . 'use core_tag_tag::get_correlated_tags(), core_tag_tag::get_related_tags() or '
3581         . 'core_tag_tag::get_manual_related_tags()', DEBUG_DEVELOPER);
3582     $result = array();
3583     if ($tag = core_tag_tag::get($tagid)) {
3584         if ($type == TAG_RELATED_CORRELATED) {
3585             $tags = $tag->get_correlated_tags();
3586         } else if ($type == TAG_RELATED_MANUAL) {
3587             $tags = $tag->get_manual_related_tags();
3588         } else {
3589             $tags = $tag->get_related_tags();
3590         }
3591         $tags = array_slice($tags, 0, $limitnum);
3592         foreach ($tags as $id => $tag) {
3593             $result[$id] = $tag->to_object();
3594         }
3595     }
3596     return $result;
3599 /**
3600  * Delete one or more tag, and all their instances if there are any left.
3601  *
3602  * @package  core_tag
3603  * @deprecated since 3.1
3604  * @param    mixed    $tagids one tagid (int), or one array of tagids to delete
3605  * @return   bool     true on success, false otherwise
3606  */
3607 function tag_delete($tagids) {
3608     debugging('Method tag_delete() is deprecated, use core_tag_tag::delete_tags()',
3609         DEBUG_DEVELOPER);
3610     return core_tag_tag::delete_tags($tagids);
3613 /**
3614  * Deletes all the tag instances given a component and an optional contextid.
3615  *
3616  * @deprecated since 3.1
3617  * @param string $component
3618  * @param int $contextid if null, then we delete all tag instances for the $component
3619  */
3620 function tag_delete_instances($component, $contextid = null) {
3621     debugging('Method tag_delete() is deprecated, use core_tag_tag::delete_instances()',
3622         DEBUG_DEVELOPER);
3623     core_tag_tag::delete_instances($component, null, $contextid);
3626 /**
3627  * Clean up the tag tables, making sure all tagged object still exists.
3628  *
3629  * This should normally not be necessary, but in case related tags are not deleted when the tagged record is removed, this should be
3630  * done once in a while, perhaps on an occasional cron run.  On a site with lots of tags, this could become an expensive function to
3631  * call: don't run at peak time.
3632  *
3633  * @package core_tag
3634  * @deprecated since 3.1
3635  */
3636 function tag_cleanup() {
3637     debugging('Method tag_cleanup() is deprecated, use \core\task\tag_cron_task::cleanup()',
3638         DEBUG_DEVELOPER);
3640     $task = new \core\task\tag_cron_task();
3641     return $task->cleanup();
3644 /**
3645  * This function will delete numerous tag instances efficiently.
3646  * This removes tag instances only. It doesn't check to see if it is the last use of a tag.
3647  *
3648  * @deprecated since 3.1
3649  * @param array $instances An array of tag instance objects with the addition of the tagname and tagrawname
3650  *        (used for recording a delete event).
3651  */
3652 function tag_bulk_delete_instances($instances) {
3653     debugging('Method tag_bulk_delete_instances() is deprecated, '
3654         . 'use \core\task\tag_cron_task::bulk_delete_instances()',
3655         DEBUG_DEVELOPER);
3657     $task = new \core\task\tag_cron_task();
3658     return $task->bulk_delete_instances($instances);
3661 /**
3662  * Calculates and stores the correlated tags of all tags. The correlations are stored in the 'tag_correlation' table.
3663  *
3664  * Two tags are correlated if they appear together a lot. Ex.: Users tagged with "computers" will probably also be tagged with "algorithms".
3665  *
3666  * The rationale for the 'tag_correlation' table is performance. It works as a cache for a potentially heavy load query done at the
3667  * 'tag_instance' table. So, the 'tag_correlation' table stores redundant information derived from the 'tag_instance' table.
3668  *
3669  * @package core_tag
3670  * @deprecated since 3.1
3671  * @param   int      $mincorrelation Only tags with more than $mincorrelation correlations will be identified.
3672  */
3673 function tag_compute_correlations($mincorrelation = 2) {
3674     debugging('Method tag_compute_correlations() is deprecated, '
3675         . 'use \core\task\tag_cron_task::compute_correlations()',
3676         DEBUG_DEVELOPER);
3678     $task = new \core\task\tag_cron_task();
3679     return $task->compute_correlations($mincorrelation);
3682 /**
3683  * This function processes a tag correlation and makes changes in the database as required.
3684  *
3685  * The tag correlation object needs have both a tagid property and a correlatedtags property that is an array.
3686  *
3687  * @package core_tag
3688  * @deprecated since 3.1
3689  * @param   stdClass $tagcorrelation
3690  * @return  int/bool The id of the tag correlation that was just processed or false.
3691  */
3692 function tag_process_computed_correlation(stdClass $tagcorrelation) {
3693     debugging('Method tag_process_computed_correlation() is deprecated, '
3694         . 'use \core\task\tag_cron_task::process_computed_correlation()',
3695         DEBUG_DEVELOPER);
3697     $task = new \core\task\tag_cron_task();
3698     return $task->process_computed_correlation($tagcorrelation);
3701 /**
3702  * Tasks that should be performed at cron time
3703  *
3704  * @package core_tag
3705  * @deprecated since 3.1
3706  */
3707 function tag_cron() {
3708     debugging('Method tag_cron() is deprecated, use \core\task\tag_cron_task::execute()',
3709         DEBUG_DEVELOPER);
3711     $task = new \core\task\tag_cron_task();
3712     $task->execute();
3715 /**
3716  * Search for tags with names that match some text
3717  *
3718  * @package core_tag
3719  * @deprecated since 3.1
3720  * @param   string        $text      escaped string that the tag names will be matched against
3721  * @param   bool          $ordered   If true, tags are ordered by their popularity. If false, no ordering.
3722  * @param   int/string    $limitfrom (optional, required if $limitnum is set) return a subset of records, starting at this point.
3723  * @param   int/string    $limitnum  (optional, required if $limitfrom is set) return a subset comprising this many records.
3724  * @param   int           $tagcollid
3725  * @return  array/boolean an array of objects, or false if no records were found or an error occured.
3726  */
3727 function tag_find_tags($text, $ordered=true, $limitfrom='', $limitnum='', $tagcollid = null) {
3728     debugging('Method tag_find_tags() is deprecated without replacement', DEBUG_DEVELOPER);
3729     global $DB;
3731     $text = core_text::strtolower(clean_param($text, PARAM_TAG));
3733     list($sql, $params) = $DB->get_in_or_equal($tagcollid ? array($tagcollid) :
3734         array_keys(core_tag_collection::get_collections(true)));
3735     array_unshift($params, "%{$text}%");
3737     if ($ordered) {
3738         $query = "SELECT tg.id, tg.name, tg.rawname, tg.tagcollid, COUNT(ti.id) AS count
3739                     FROM {tag} tg LEFT JOIN {tag_instance} ti ON tg.id = ti.tagid
3740                    WHERE tg.name LIKE ? AND tg.tagcollid $sql
3741                 GROUP BY tg.id, tg.name, tg.rawname
3742                 ORDER BY count DESC";
3743     } else {
3744         $query = "SELECT tg.id, tg.name, tg.rawname, tg.tagcollid
3745                     FROM {tag} tg
3746                    WHERE tg.name LIKE ? AND tg.tagcollid $sql";
3747     }
3748     return $DB->get_records_sql($query, $params, $limitfrom , $limitnum);
3751 /**
3752  * Get the name of a tag
3753  *
3754  * @package core_tag
3755  * @deprecated since 3.1
3756  * @param   mixed    $tagids the id of the tag, or an array of ids
3757  * @return  mixed    string name of one tag, or id-indexed array of strings
3758  */
3759 function tag_get_name($tagids) {
3760     debugging('Method tag_get_name() is deprecated without replacement', DEBUG_DEVELOPER);
3761     global $DB;
3763     if (!is_array($tagids)) {
3764         if ($tag = $DB->get_record('tag', array('id'=>$tagids))) {
3765             return $tag->name;
3766         }
3767         return false;
3768     }
3770     $tag_names = array();
3771     foreach($DB->get_records_list('tag', 'id', $tagids) as $tag) {
3772         $tag_names[$tag->id] = $tag->name;
3773     }
3775     return $tag_names;
3778 /**
3779  * Returns the correlated tags of a tag, retrieved from the tag_correlation table. Make sure cron runs, otherwise the table will be
3780  * empty and this function won't return anything.
3781  *
3782  * Correlated tags are calculated in cron based on existing tag instances.
3783  *
3784  * @package core_tag
3785  * @deprecated since 3.1
3786  * @param   int      $tagid   is a single tag id
3787  * @param   int      $notused  this argument is no longer used
3788  * @return  array    an array of tag objects or an empty if no correlated tags are found
3789  */
3790 function tag_get_correlated($tagid, $notused = null) {
3791     debugging('Method tag_get_correlated() is deprecated, '
3792         . 'use core_tag_tag::get_correlated_tags()', DEBUG_DEVELOPER);
3793     $result = array();
3794     if ($tag = core_tag_tag::get($tagid)) {
3795         $tags = $tag->get_correlated_tags(true);
3796         // Convert to objects for backward-compatibility.
3797         foreach ($tags as $id => $tag) {
3798             $result[$id] = $tag->to_object();
3799         }
3800     }
3801     return $result;
3804 /**
3805  * This function is used by print_tag_cloud, to usort() the tags in the cloud. See php.net/usort for the parameters documentation.
3806  * This was originally in blocks/blog_tags/block_blog_tags.php, named blog_tags_sort().
3807  *
3808  * @package core_tag
3809  * @deprecated since 3.1
3810  * @param   string $a Tag name to compare against $b
3811  * @param   string $b Tag name to compare against $a
3812  * @return  int    The result of the comparison/validation 1, 0 or -1
3813  */
3814 function tag_cloud_sort($a, $b) {
3815     debugging('Method tag_cloud_sort() is deprecated, similar method can be found in core_tag_collection::cloud_sort()', DEBUG_DEVELOPER);
3816     global $CFG;
3818     if (empty($CFG->tagsort)) {
3819         $tagsort = 'name'; // by default, sort by name
3820     } else {
3821         $tagsort = $CFG->tagsort;
3822     }
3824     if (is_numeric($a->$tagsort)) {
3825         return ($a->$tagsort == $b->$tagsort) ? 0 : ($a->$tagsort > $b->$tagsort) ? 1 : -1;
3826     } elseif (is_string($a->$tagsort)) {
3827         return strcmp($a->$tagsort, $b->$tagsort);
3828     } else {
3829         return 0;
3830     }
3833 /**
3834  * Loads the events definitions for the component (from file). If no
3835  * events are defined for the component, we simply return an empty array.
3836  *
3837  * @access protected To be used from eventslib only
3838  * @deprecated since Moodle 3.1
3839  * @param string $component examples: 'moodle', 'mod_forum', 'block_quiz_results'
3840  * @return array Array of capabilities or empty array if not exists
3841  */
3842 function events_load_def($component) {
3843     global $CFG;
3844     if ($component === 'unittest') {
3845         $defpath = $CFG->dirroot.'/lib/tests/fixtures/events.php';
3846     } else {
3847         $defpath = core_component::get_component_directory($component).'/db/events.php';
3848     }
3850     $handlers = array();
3852     if (file_exists($defpath)) {
3853         require($defpath);
3854     }
3856     // make sure the definitions are valid and complete; tell devs what is wrong
3857     foreach ($handlers as $eventname => $handler) {
3858         if ($eventname === 'reset') {
3859             debugging("'reset' can not be used as event name.");
3860             unset($handlers['reset']);
3861             continue;
3862         }
3863         if (!is_array($handler)) {
3864             debugging("Handler of '$eventname' must be specified as array'");
3865             unset($handlers[$eventname]);
3866             continue;
3867         }
3868         if (!isset($handler['handlerfile'])) {
3869             debugging("Handler of '$eventname' must include 'handlerfile' key'");
3870             unset($handlers[$eventname]);
3871             continue;
3872         }
3873         if (!isset($handler['handlerfunction'])) {
3874             debugging("Handler of '$eventname' must include 'handlerfunction' key'");
3875             unset($handlers[$eventname]);
3876             continue;
3877         }
3878         if (!isset($handler['schedule'])) {
3879             $handler['schedule'] = 'instant';
3880         }
3881         if ($handler['schedule'] !== 'instant' and $handler['schedule'] !== 'cron') {
3882             debugging("Handler of '$eventname' must include valid 'schedule' type (instant or cron)'");
3883             unset($handlers[$eventname]);
3884             continue;
3885         }
3886         if (!isset($handler['internal'])) {
3887             $handler['internal'] = 1;
3888         }
3889         $handlers[$eventname] = $handler;
3890     }
3892     return $handlers;
3895 /**
3896  * Puts a handler on queue
3897  *
3898  * @access protected To be used from eventslib only
3899  * @deprecated since Moodle 3.1
3900  * @param stdClass $handler event handler object from db
3901  * @param stdClass $event event data object
3902  * @param string $errormessage The error message indicating the problem
3903  * @return int id number of new queue handler
3904  */
3905 function events_queue_handler($handler, $event, $errormessage) {
3906     global $DB;
3908     if ($qhandler = $DB->get_record('events_queue_handlers', array('queuedeventid'=>$event->id, 'handlerid'=>$handler->id))) {
3909         debugging("Please check code: Event id $event->id is already queued in handler id $qhandler->id");
3910         return $qhandler->id;
3911     }
3913     // make a new queue handler
3914     $qhandler = new stdClass();
3915     $qhandler->queuedeventid  = $event->id;
3916     $qhandler->handlerid      = $handler->id;
3917     $qhandler->errormessage   = $errormessage;
3918     $qhandler->timemodified   = time();
3919     if ($handler->schedule === 'instant' and $handler->status == 1) {
3920         $qhandler->status     = 1; //already one failed attempt to dispatch this event
3921     } else {
3922         $qhandler->status     = 0;
3923     }
3925     return $DB->insert_record('events_queue_handlers', $qhandler);
3928 /**
3929  * trigger a single event with a specified handler
3930  *
3931  * @access protected To be used from eventslib only
3932  * @deprecated since Moodle 3.1
3933  * @param stdClass $handler This shoudl be a row from the events_handlers table.
3934  * @param stdClass $eventdata An object containing information about the event
3935  * @param string $errormessage error message indicating problem
3936  * @return bool|null True means event processed, false means retry event later; may throw exception, NULL means internal error
3937  */
3938 function events_dispatch($handler, $eventdata, &$errormessage) {
3939     global $CFG;
3941     debugging('Events API using $handlers array has been deprecated in favour of Events 2 API, please use it instead.', DEBUG_DEVELOPER);
3943     $function = unserialize($handler->handlerfunction);
3945     if (is_callable($function)) {
3946         // oki, no need for includes
3948     } else if (file_exists($CFG->dirroot.$handler->handlerfile)) {
3949         include_once($CFG->dirroot.$handler->handlerfile);
3951     } else {
3952         $errormessage = "Handler file of component $handler->component: $handler->handlerfile can not be found!";
3953         return null;
3954     }
3956     // checks for handler validity
3957     if (is_callable($function)) {
3958         $result = call_user_func($function, $eventdata);
3959         if ($result === false) {
3960             $errormessage = "Handler function of component $handler->component: $handler->handlerfunction requested resending of event!";
3961             return false;
3962         }
3963         return true;
3965     } else {
3966         $errormessage = "Handler function of component $handler->component: $handler->handlerfunction not callable function or class method!";
3967         return null;
3968     }
3971 /**
3972  * given a queued handler, call the respective event handler to process the event
3973  *
3974  * @access protected To be used from eventslib only
3975  * @deprecated since Moodle 3.1
3976  * @param stdClass $qhandler events_queued_handler row from db
3977  * @return boolean true means event processed, false means retry later, NULL means fatal failure
3978  */
3979 function events_process_queued_handler($qhandler) {
3980     global $DB;
3982     // get handler
3983     if (!$handler = $DB->get_record('events_handlers', array('id'=>$qhandler->handlerid))) {
3984         debugging("Error processing queue handler $qhandler->id, missing handler id: $qhandler->handlerid");
3985         //irrecoverable error, remove broken queue handler
3986         events_dequeue($qhandler);
3987         return NULL;
3988     }
3990     // get event object
3991     if (!$event = $DB->get_record('events_queue', array('id'=>$qhandler->queuedeventid))) {
3992         // can't proceed with no event object - might happen when two crons running at the same time
3993         debugging("Error processing queue handler $qhandler->id, missing event id: $qhandler->queuedeventid");
3994         //irrecoverable error, remove broken queue handler
3995         events_dequeue($qhandler);
3996         return NULL;
3997     }
3999     // call the function specified by the handler
4000     try {
4001         $errormessage = 'Unknown error';
4002         if (events_dispatch($handler, unserialize(base64_decode($event->eventdata)), $errormessage)) {
4003             //everything ok
4004             events_dequeue($qhandler);
4005             return true;
4006         }
4007     } catch (Exception $e) {
4008         // the problem here is that we do not want one broken handler to stop all others,
4009         // cron handlers are very tricky because the needed data might have been deleted before the cron execution
4010         $errormessage = "Handler function of component $handler->component: $handler->handlerfunction threw exception :" .
4011                 $e->getMessage() . "\n" . format_backtrace($e->getTrace(), true);
4012         if (!empty($e->debuginfo)) {
4013             $errormessage .= $e->debuginfo;
4014         }
4015     }
4017     //dispatching failed
4018     $qh = new stdClass();
4019     $qh->id           = $qhandler->id;
4020     $qh->errormessage = $errormessage;
4021     $qh->timemodified = time();
4022     $qh->status       = $qhandler->status + 1;
4023     $DB->update_record('events_queue_handlers', $qh);
4025     debugging($errormessage);
4027     return false;
4030 /**
4031  * Updates all of the event definitions within the database.
4032  *
4033  * Unfortunately this isn't as simple as removing them all and then readding
4034  * the updated event definitions. Chances are queued items are referencing the
4035  * existing definitions.
4036  *
4037  * Note that the absence of the db/events.php event definition file
4038  * will cause any queued events for the component to be removed from
4039  * the database.
4040  *
4041  * @category event
4042  * @deprecated since Moodle 3.1
4043  * @param string $component examples: 'moodle', 'mod_forum', 'block_quiz_results'
4044  * @return boolean always returns true
4045  */
4046 function events_update_definition($component='moodle') {
4047     global $DB;
4049     // load event definition from events.php
4050     $filehandlers = events_load_def($component);
4052     if ($filehandlers) {
4053         debugging('Events API using $handlers array has been deprecated in favour of Events 2 API, please use it instead.', DEBUG_DEVELOPER);
4054     }
4056     // load event definitions from db tables
4057     // if we detect an event being already stored, we discard from this array later
4058     // the remaining needs to be removed
4059     $cachedhandlers = events_get_cached($component);
4061     foreach ($filehandlers as $eventname => $filehandler) {
4062         if (!empty($cachedhandlers[$eventname])) {
4063             if ($cachedhandlers[$eventname]['handlerfile'] === $filehandler['handlerfile'] &&
4064                 $cachedhandlers[$eventname]['handlerfunction'] === serialize($filehandler['handlerfunction']) &&
4065                 $cachedhandlers[$eventname]['schedule'] === $filehandler['schedule'] &&
4066                 $cachedhandlers[$eventname]['internal'] == $filehandler['internal']) {
4067                 // exact same event handler already present in db, ignore this entry
4069                 unset($cachedhandlers[$eventname]);
4070                 continue;
4072             } else {
4073                 // same event name matches, this event has been updated, update the datebase
4074                 $handler = new stdClass();
4075                 $handler->id              = $cachedhandlers[$eventname]['id'];
4076                 $handler->handlerfile     = $filehandler['handlerfile'];
4077                 $handler->handlerfunction = serialize($filehandler['handlerfunction']); // static class methods stored as array
4078                 $handler->schedule        = $filehandler['schedule'];
4079                 $handler->internal        = $filehandler['internal'];
4081                 $DB->update_record('events_handlers', $handler);
4083                 unset($cachedhandlers[$eventname]);
4084                 continue;
4085             }
4087         } else {
4088             // if we are here, this event handler is not present in db (new)
4089             // add it
4090             $handler = new stdClass();
4091             $handler->eventname       = $eventname;
4092             $handler->component       = $component;
4093             $handler->handlerfile     = $filehandler['handlerfile'];
4094             $handler->handlerfunction = serialize($filehandler['handlerfunction']); // static class methods stored as array
4095             $handler->schedule        = $filehandler['schedule'];
4096             $handler->status          = 0;
4097             $handler->internal        = $filehandler['internal'];
4099             $DB->insert_record('events_handlers', $handler);
4100         }
4101     }
4103     // clean up the left overs, the entries in cached events array at this points are deprecated event handlers
4104     // and should be removed, delete from db
4105     events_cleanup($component, $cachedhandlers);
4107     events_get_handlers('reset');
4109     return true;
4112 /**
4113  * Events cron will try to empty the events queue by processing all the queued events handlers
4114  *
4115  * @access public Part of the public API
4116  * @deprecated since Moodle 3.1
4117  * @category event
4118  * @param string $eventname empty means all
4119  * @return int number of dispatched events
4120  */
4121 function events_cron($eventname='') {
4122     global $DB;
4124     $failed = array();
4125     $processed = 0;
4127     if ($eventname) {
4128         $sql = "SELECT qh.*
4129                   FROM {events_queue_handlers} qh, {events_handlers} h
4130                  WHERE qh.handlerid = h.id AND h.eventname=?
4131               ORDER BY qh.id";
4132         $params = array($eventname);
4133     } else {
4134         $sql = "SELECT *
4135                   FROM {events_queue_handlers}
4136               ORDER BY id";
4137         $params = array();
4138     }
4140     $rs = $DB->get_recordset_sql($sql, $params);
4141     if ($rs->valid()) {
4142         debugging('Events API using $handlers array has been deprecated in favour of Events 2 API, please use it instead.', DEBUG_DEVELOPER);
4143     }
4145     foreach ($rs as $qhandler) {
4146         if (isset($failed[$qhandler->handlerid])) {
4147             // do not try to dispatch any later events when one already asked for retry or ended with exception
4148             continue;
4149         }
4150         $status = events_process_queued_handler($qhandler);
4151         if ($status === false) {
4152             // handler is asking for retry, do not send other events to this handler now
4153             $failed[$qhandler->handlerid] = $qhandler->handlerid;
4154         } else if ($status === NULL) {
4155             // means completely broken handler, event data was purged
4156             $failed[$qhandler->handlerid] = $qhandler->handlerid;
4157         } else {
4158             $processed++;
4159         }
4160     }
4161     $rs->close();
4163     // remove events that do not have any handlers waiting
4164     $sql = "SELECT eq.id
4165               FROM {events_queue} eq
4166               LEFT JOIN {events_queue_handlers} qh ON qh.queuedeventid = eq.id
4167              WHERE qh.id IS NULL";
4168     $rs = $DB->get_recordset_sql($sql);
4169     foreach ($rs as $event) {
4170         //debugging('Purging stale event '.$event->id);
4171         $DB->delete_records('events_queue', array('id'=>$event->id));
4172     }
4173     $rs->close();
4175     return $processed;
4178 /**
4179  * Do not call directly, this is intended to be used from new event base only.
4180  *
4181  * @private
4182  * @deprecated since Moodle 3.1
4183  * @param string $eventname name of the event
4184  * @param mixed $eventdata event data object
4185  * @return int number of failed events
4186  */
4187 function events_trigger_legacy($eventname, $eventdata) {
4188     global $CFG, $USER, $DB;
4190     $failedcount = 0; // number of failed events.
4192     // pull out all registered event handlers
4193     if ($handlers = events_get_handlers($eventname)) {
4194         foreach ($handlers as $handler) {
4195             $errormessage = '';
4197             if ($handler->schedule === 'instant') {
4198                 if ($handler->status) {
4199                     //check if previous pending events processed
4200                     if (!$DB->record_exists('events_queue_handlers', array('handlerid'=>$handler->id))) {
4201                         // ok, queue is empty, lets reset the status back to 0 == ok
4202                         $handler->status = 0;
4203                         $DB->set_field('events_handlers', 'status', 0, array('id'=>$handler->id));
4204                         // reset static handler cache
4205                         events_get_handlers('reset');
4206                     }
4207                 }
4209                 // dispatch the event only if instant schedule and status ok
4210                 if ($handler->status or (!$handler->internal and $DB->is_transaction_started())) {
4211                     // increment the error status counter
4212                     $handler->status++;
4213                     $DB->set_field('events_handlers', 'status', $handler->status, array('id'=>$handler->id));
4214                     // reset static handler cache
4215                     events_get_handlers('reset');
4217                 } else {
4218                     $errormessage = 'Unknown error';
4219                     $result = events_dispatch($handler, $eventdata, $errormessage);
4220                     if ($result === true) {
4221                         // everything is fine - event dispatched
4222                         continue;
4223                     } else if ($result === false) {
4224                         // retry later - set error count to 1 == send next instant into cron queue
4225                         $DB->set_field('events_handlers', 'status', 1, array('id'=>$handler->id));
4226                         // reset static handler cache
4227                         events_get_handlers('reset');
4228                     } else {
4229                         // internal problem - ignore the event completely
4230                         $failedcount ++;
4231                         continue;
4232                     }
4233                 }
4235                 // update the failed counter
4236                 $failedcount ++;
4238             } else if ($handler->schedule === 'cron') {
4239                 //ok - use queueing of events only
4241             } else {
4242                 // unknown schedule - ignore event completely
4243                 debugging("Unknown handler schedule type: $handler->schedule");
4244                 $failedcount ++;
4245                 continue;
4246             }
4248             // if even type is not instant, or dispatch asked for retry, queue it
4249             $event = new stdClass();
4250             $event->userid      = $USER->id;
4251             $event->eventdata   = base64_encode(serialize($eventdata));
4252             $event->timecreated = time();
4253             if (debugging()) {
4254                 $dump = '';
4255                 $callers = debug_backtrace();
4256                 foreach ($callers as $caller) {
4257                     if (!isset($caller['line'])) {
4258                         $caller['line'] = '?';
4259                     }
4260                     if (!isset($caller['file'])) {
4261                         $caller['file'] = '?';
4262                     }
4263                     $dump .= 'line ' . $caller['line'] . ' of ' . substr($caller['file'], strlen($CFG->dirroot) + 1);
4264                     if (isset($caller['function'])) {
4265                         $dump .= ': call to ';
4266                         if (isset($caller['class'])) {
4267                             $dump .= $caller['class'] . $caller['type'];
4268                         }
4269                         $dump .= $caller['function'] . '()';
4270                     }
4271                     $dump .= "\n";
4272                 }
4273                 $event->stackdump = $dump;
4274             } else {
4275                 $event->stackdump = '';
4276             }
4277             $event->id = $DB->insert_record('events_queue', $event);
4278             events_queue_handler($handler, $event, $errormessage);
4279         }
4280     } else {
4281         // No handler found for this event name - this is ok!
4282     }
4284     return $failedcount;
4287 /**
4288  * checks if an event is registered for this component
4289  *
4290  * @access public Part of the public API
4291  * @deprecated since Moodle 3.1
4292  * @param string $eventname name of the event
4293  * @param string $component component name, can be mod/data or moodle
4294  * @return bool
4295  */
4296 function events_is_registered($eventname, $component) {
4297     global $DB;
4299     debugging('events_is_registered() has been deprecated along with all Events 1 API in favour of Events 2 API,' .
4300         ' please use it instead.', DEBUG_DEVELOPER);
4302     return $DB->record_exists('events_handlers', array('component'=>$component, 'eventname'=>$eventname));
4305 /**
4306  * checks if an event is queued for processing - either cron handlers attached or failed instant handlers
4307  *
4308  * @access public Part of the public API
4309  * @deprecated since Moodle 3.1
4310  * @param string $eventname name of the event
4311  * @return int number of queued events
4312  */
4313 function events_pending_count($eventname) {
4314     global $DB;
4316     debugging('events_pending_count() has been deprecated along with all Events 1 API in favour of Events 2 API,' .
4317         ' please use it instead.', DEBUG_DEVELOPER);
4319     $sql = "SELECT COUNT('x')
4320               FROM {events_queue_handlers} qh
4321               JOIN {events_handlers} h ON h.id = qh.handlerid
4322              WHERE h.eventname = ?";
4324     return $DB->count_records_sql($sql, array($eventname));
4327 /**
4328  * Emails admins about a clam outcome
4329  *
4330  * @deprecated since Moodle 3.0 - this is a part of clamav plugin now.
4331  * @param string $notice The body of the email to be sent.
4332  * @return void
4333  */
4334 function clam_message_admins($notice) {
4335     debugging('clam_message_admins() is deprecated, please use message_admins() method of \antivirus_clamav\scanner class.', DEBUG_DEVELOPER);
4337     $antivirus = \core\antivirus\manager::get_antivirus('clamav');
4338     $antivirus->message_admins($notice);
4341 /**
4342  * Returns the string equivalent of a numeric clam error code
4343  *
4344  * @deprecated since Moodle 3.0 - this is a part of clamav plugin now.
4345  * @param int $returncode The numeric error code in question.
4346  * @return string The definition of the error code
4347  */
4348 function get_clam_error_code($returncode) {
4349     debugging('get_clam_error_code() is deprecated, please use get_clam_error_code() method of \antivirus_clamav\scanner class.', DEBUG_DEVELOPER);
4351     $antivirus = \core\antivirus\manager::get_antivirus('clamav');
4352     return $antivirus->get_clam_error_code($returncode);
4355 /**
4356  * Returns the rename action.
4357  *
4358  * @deprecated since 3.1
4359  * @param cm_info $mod The module to produce editing buttons for
4360  * @param int $sr The section to link back to (used for creating the links)
4361  * @return The markup for the rename action, or an empty string if not available.
4362  */
4363 function course_get_cm_rename_action(cm_info $mod, $sr = null) {
4364     global $COURSE, $OUTPUT;
4366     static $str;
4367     static $baseurl;
4369     debugging('Function course_get_cm_rename_action() is deprecated. Please use inplace_editable ' .
4370         'https://docs.moodle.org/dev/Inplace_editable', DEBUG_DEVELOPER);
4372     $modcontext = context_module::instance($mod->id);
4373     $hasmanageactivities = has_capability('moodle/course:manageactivities', $modcontext);
4375     if (!isset($str)) {
4376         $str = get_strings(array('edittitle'));
4377     }
4379     if (!isset($baseurl)) {
4380         $baseurl = new moodle_url('/course/mod.php', array('sesskey' => sesskey()));
4381     }
4383     if ($sr !== null) {
4384         $baseurl->param('sr', $sr);
4385     }
4387     // AJAX edit title.
4388     if ($mod->has_view() && $hasmanageactivities && course_ajax_enabled($COURSE) &&
4389         (($mod->course == $COURSE->id) || ($mod->course == SITEID))) {
4390         // we will not display link if we are on some other-course page (where we should not see this module anyway)
4391         return html_writer::span(
4392             html_writer::link(
4393                 new moodle_url($baseurl, array('update' => $mod->id)),
4394                 $OUTPUT->pix_icon('t/editstring', '', 'moodle', array('class' => 'iconsmall visibleifjs', 'title' => '')),
4395                 array(
4396                     'class' => 'editing_title',
4397                     'data-action' => 'edittitle',
4398                     'title' => $str->edittitle,
4399                 )
4400             )