Commit | Line | Data |
---|---|---|
c861fe2f | 1 | <?php |
2 | ||
a5cb8d69 | 3 | // This file is part of Moodle - http://moodle.org/ |
4 | // | |
c861fe2f | 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. | |
a5cb8d69 | 14 | // |
c861fe2f | 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/>. | |
c4d0753b | 17 | |
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 | * | |
78bfb562 | 24 | * @package core |
c861fe2f | 25 | * @subpackage deprecated |
78bfb562 PS |
26 | * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com} |
27 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
c861fe2f | 28 | * @deprecated |
c4d0753b | 29 | */ |
30 | ||
78bfb562 PS |
31 | defined('MOODLE_INTERNAL') || die(); |
32 | ||
33c46db5 AA |
33 | /* === Functions that needs to be kept longer in deprecated lib than normal time period === */ |
34 | ||
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); | |
51 | ||
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 | } | |
59 | ||
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 | } | |
73 | ||
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; | |
93 | ||
94 | // NOTE: do not add any other debugging here, keep forever. | |
95 | ||
96 | $subsystems = core_component::get_core_subsystems(); | |
97 | ||
98 | if ($fullpaths) { | |
99 | return $subsystems; | |
100 | } | |
101 | ||
102 | debugging('Short paths are deprecated when using get_core_subsystems(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER); | |
103 | ||
104 | $dlength = strlen($CFG->dirroot); | |
105 | ||
106 | foreach ($subsystems as $k => $v) { | |
107 | if ($v === null) { | |
108 | continue; | |
109 | } | |
110 | $subsystems[$k] = substr($v, $dlength+1); | |
111 | } | |
112 | ||
113 | return $subsystems; | |
114 | } | |
115 | ||
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; | |
126 | ||
127 | // NOTE: do not add any other debugging here, keep forever. | |
128 | ||
129 | $types = core_component::get_plugin_types(); | |
130 | ||
131 | if ($fullpaths) { | |
132 | return $types; | |
133 | } | |
134 | ||
135 | debugging('Short paths are deprecated when using get_plugin_types(), please fix the code to use fullpaths instead.', DEBUG_DEVELOPER); | |
136 | ||
137 | $dlength = strlen($CFG->dirroot); | |
138 | ||
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 | } | |
146 | ||
147 | return $types; | |
148 | } | |
149 | ||
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) { | |
159 | ||
160 | // NOTE: do not add any other debugging here, keep forever. | |
161 | ||
162 | if ($plugintype === '') { | |
163 | $plugintype = 'mod'; | |
164 | } | |
165 | ||
166 | return core_component::get_plugin_list($plugintype); | |
167 | } | |
168 | ||
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) { | |
185 | ||
186 | // NOTE: do not add any other debugging here, keep forever. | |
187 | ||
188 | return core_component::get_plugin_list_with_class($plugintype, $class, $file); | |
189 | } | |
190 | ||
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) { | |
201 | ||
202 | // NOTE: do not add any other debugging here, keep forever. | |
203 | ||
204 | if ($plugintype === '') { | |
205 | $plugintype = 'mod'; | |
206 | } | |
207 | ||
208 | return core_component::get_plugin_directory($plugintype, $name); | |
209 | } | |
210 | ||
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) { | |
220 | ||
221 | // NOTE: do not add any other debugging here, keep forever. | |
222 | ||
223 | return core_component::normalize_component($component); | |
224 | } | |
225 | ||
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) { | |
235 | ||
236 | // NOTE: do not add any other debugging here, keep forever. | |
237 | ||
238 | return core_component::get_component_directory($component); | |
239 | } | |
240 | ||
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) { | |
255 | ||
256 | debugging('get_context_instance() is deprecated, please use context_xxxx::instance() instead.', DEBUG_DEVELOPER); | |
257 | ||
258 | $instances = (array)$instance; | |
259 | $contexts = array(); | |
260 | ||
261 | $classname = context_helper::get_class_for_level($contextlevel); | |
262 | ||
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 | } | |
267 | ||
268 | if (is_array($instance)) { | |
269 | return $contexts; | |
270 | } else { | |
271 | return $contexts[$instance]; | |
272 | } | |
273 | } | |
274 | /* === End of long term deprecated api list === */ | |
275 | ||
114e3209 PÅ |
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 | * | |
114e3209 PÅ |
281 | */ |
282 | function clam_log_upload($newfilepath, $course=null, $nourl=false) { | |
6dd7175a | 283 | throw new coding_exception('clam_log_upload() can not be used any more, please use file picker instead'); |
114e3209 PÅ |
284 | } |
285 | ||
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 | * | |
114e3209 PÅ |
291 | */ |
292 | function clam_log_infected($oldfilepath='', $newfilepath='', $userid=0) { | |
6dd7175a | 293 | throw new coding_exception('clam_log_infected() can not be used any more, please use file picker instead'); |
114e3209 PÅ |
294 | } |
295 | ||
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 | * | |
114e3209 PÅ |
301 | */ |
302 | function clam_change_log($oldpath, $newpath, $update=true) { | |
6dd7175a | 303 | throw new coding_exception('clam_change_log() can not be used any more, please use file picker instead'); |
114e3209 PÅ |
304 | } |
305 | ||
306 | /** | |
307 | * Replaces the given file with a string. | |
308 | * | |
309 | * @deprecated since 2.7 - infected files are now deleted in file picker | |
310 | * | |
114e3209 PÅ |
311 | */ |
312 | function clam_replace_infected_file($file) { | |
6dd7175a | 313 | throw new coding_exception('clam_replace_infected_file() can not be used any more, please use file picker instead'); |
114e3209 PÅ |
314 | } |
315 | ||
7293a1aa DP |
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'); | |
326 | } | |
327 | ||
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'); | |
335 | } | |
336 | ||
337 | ||
6780a1d3 PÅ |
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 | * | |
6780a1d3 PÅ |
347 | */ |
348 | function password_compat_not_supported() { | |
1ac1d29b | 349 | throw new coding_exception('Do not use password_compat_not_supported() - bcrypt is now always available'); |
6780a1d3 PÅ |
350 | } |
351 | ||
d79d5ac2 PS |
352 | /** |
353 | * Factory method that was returning moodle_session object. | |
354 | * | |
355 | * @deprecated since 2.6 | |
d79d5ac2 PS |
356 | */ |
357 | function session_get_instance() { | |
2149326b | 358 | throw new coding_exception('session_get_instance() is removed, use \core\session\manager instead'); |
d79d5ac2 PS |
359 | } |
360 | ||
361 | /** | |
362 | * Returns true if legacy session used. | |
363 | * | |
364 | * @deprecated since 2.6 | |
d79d5ac2 PS |
365 | */ |
366 | function session_is_legacy() { | |
2149326b | 367 | throw new coding_exception('session_is_legacy() is removed, do not use any more'); |
d79d5ac2 PS |
368 | } |
369 | ||
370 | /** | |
371 | * Terminates all sessions, auth hooks are not executed. | |
d79d5ac2 PS |
372 | * |
373 | * @deprecated since 2.6 | |
374 | */ | |
375 | function session_kill_all() { | |
2149326b | 376 | throw new coding_exception('session_kill_all() is removed, use \core\session\manager::kill_all_sessions() instead'); |
d79d5ac2 PS |
377 | } |
378 | ||
379 | /** | |
380 | * Mark session as accessed, prevents timeouts. | |
381 | * | |
382 | * @deprecated since 2.6 | |
d79d5ac2 PS |
383 | */ |
384 | function session_touch($sid) { | |
2149326b | 385 | throw new coding_exception('session_touch() is removed, use \core\session\manager::touch_session() instead'); |
d79d5ac2 PS |
386 | } |
387 | ||
388 | /** | |
389 | * Terminates one sessions, auth hooks are not executed. | |
390 | * | |
391 | * @deprecated since 2.6 | |
d79d5ac2 PS |
392 | */ |
393 | function session_kill($sid) { | |
2149326b | 394 | throw new coding_exception('session_kill() is removed, use \core\session\manager::kill_session() instead'); |
d79d5ac2 PS |
395 | } |
396 | ||
397 | /** | |
398 | * Terminates all sessions of one user, auth hooks are not executed. | |
d79d5ac2 PS |
399 | * |
400 | * @deprecated since 2.6 | |
d79d5ac2 PS |
401 | */ |
402 | function session_kill_user($userid) { | |
2149326b | 403 | throw new coding_exception('session_kill_user() is removed, use \core\session\manager::kill_user_sessions() instead'); |
d79d5ac2 PS |
404 | } |
405 | ||
d79d5ac2 PS |
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 | |
d79d5ac2 PS |
412 | */ |
413 | function session_set_user($user) { | |
2149326b | 414 | throw new coding_exception('session_set_user() is removed, use \core\session\manager::set_user() instead'); |
d79d5ac2 PS |
415 | } |
416 | ||
417 | /** | |
418 | * Is current $USER logged-in-as somebody else? | |
419 | * @deprecated since 2.6 | |
d79d5ac2 PS |
420 | */ |
421 | function session_is_loggedinas() { | |
2149326b | 422 | throw new coding_exception('session_is_loggedinas() is removed, use \core\session\manager::is_loggedinas() instead'); |
d79d5ac2 PS |
423 | } |
424 | ||
425 | /** | |
426 | * Returns the $USER object ignoring current login-as session | |
427 | * @deprecated since 2.6 | |
d79d5ac2 PS |
428 | */ |
429 | function session_get_realuser() { | |
2149326b | 430 | throw new coding_exception('session_get_realuser() is removed, use \core\session\manager::get_realuser() instead'); |
d79d5ac2 PS |
431 | } |
432 | ||
433 | /** | |
434 | * Login as another user - no security checks here. | |
435 | * @deprecated since 2.6 | |
d79d5ac2 PS |
436 | */ |
437 | function session_loginas($userid, $context) { | |
2149326b | 438 | throw new coding_exception('session_loginas() is removed, use \core\session\manager::loginas() instead'); |
d79d5ac2 PS |
439 | } |
440 | ||
6b32d6bc PS |
441 | /** |
442 | * Minify JavaScript files. | |
443 | * | |
444 | * @deprecated since 2.6 | |
6b32d6bc PS |
445 | */ |
446 | function js_minify($files) { | |
2149326b | 447 | throw new coding_exception('js_minify() is removed, use core_minify::js_files() or core_minify::js() instead.'); |
6b32d6bc PS |
448 | } |
449 | ||
450 | /** | |
451 | * Minify CSS files. | |
452 | * | |
453 | * @deprecated since 2.6 | |
6b32d6bc PS |
454 | */ |
455 | function css_minify_css($files) { | |
2149326b | 456 | throw new coding_exception('css_minify_css() is removed, use core_minify::css_files() or core_minify::css() instead.'); |
6b32d6bc PS |
457 | } |
458 | ||
9e19a0f0 PS |
459 | // === Deprecated before 2.6.0 === |
460 | ||
689096bc PS |
461 | /** |
462 | * Hack to find out the GD version by parsing phpinfo output | |
2a723541 JP |
463 | * |
464 | * @deprecated | |
689096bc PS |
465 | */ |
466 | function check_gd_version() { | |
2149326b | 467 | throw new coding_exception('check_gd_version() is removed, GD extension is always available now'); |
689096bc PS |
468 | } |
469 | ||
b28247fe PS |
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() { | |
2149326b | 476 | throw new coding_exception('update_login_count() is removed, all calls need to be removed'); |
b28247fe PS |
477 | } |
478 | ||
479 | /** | |
480 | * Not used any more, replaced by proper account lockout. | |
481 | * @deprecated | |
482 | */ | |
483 | function reset_login_count() { | |
2149326b | 484 | throw new coding_exception('reset_login_count() is removed, all calls need to be removed'); |
b28247fe PS |
485 | } |
486 | ||
c6d75bff | 487 | /** |
c6d75bff | 488 | * @deprecated |
c6d75bff PS |
489 | */ |
490 | function update_log_display_entry($module, $action, $mtable, $field) { | |
c6d75bff | 491 | |
2149326b | 492 | throw new coding_exception('The update_log_display_entry() is removed, please use db/log.php description file instead.'); |
c6d75bff PS |
493 | } |
494 | ||
35716b86 | 495 | /** |
05226d76 | 496 | * @deprecated use the text formatting in a standard way instead (http://docs.moodle.org/dev/Output_functions) |
35716b86 | 497 | * this was abused mostly for embedding of attachments |
35716b86 PS |
498 | */ |
499 | function filter_text($text, $courseid = NULL) { | |
e4d9185e | 500 | throw new coding_exception('filter_text() can not be used anymore, use format_text(), format_string() etc instead.'); |
35716b86 PS |
501 | } |
502 | ||
17c70aa0 | 503 | /** |
17c70aa0 PS |
504 | * @deprecated use $PAGE->https_required() instead |
505 | */ | |
506 | function httpsrequired() { | |
e4d9185e | 507 | throw new coding_exception('httpsrequired() can not be used any more use $PAGE->https_required() instead.'); |
17c70aa0 PS |
508 | } |
509 | ||
50a8bd6c PS |
510 | /** |
511 | * Given a physical path to a file, returns the URL through which it can be reached in Moodle. | |
512 | * | |
11d4bea2 SL |
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. | |
50a8bd6c PS |
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') { | |
11d4bea2 | 523 | debugging('Function get_file_url() is deprecated, please use moodle_url factory methods instead.', DEBUG_DEVELOPER); |
17c70aa0 | 524 | global $CFG; |
50a8bd6c PS |
525 | |
526 | $path = str_replace('//', '/', $path); | |
527 | $path = trim($path, '/'); // no leading and trailing slashes | |
528 | ||
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 | } | |
544 | ||
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 = '&'; | |
560 | } | |
561 | ||
562 | if ($options) { | |
563 | foreach ($options as $name=>$value) { | |
564 | $ffurl = $ffurl.$separator.$name.'='.$value; | |
565 | $separator = '&'; | |
566 | } | |
567 | } | |
568 | ||
569 | return $ffurl; | |
570 | } | |
571 | ||
613bbd7c | 572 | /** |
05226d76 | 573 | * @deprecated use get_enrolled_users($context) instead. |
613bbd7c | 574 | */ |
4f0c2d00 | 575 | function get_course_participants($courseid) { |
e4d9185e | 576 | throw new coding_exception('get_course_participants() can not be used any more, use get_enrolled_users() instead.'); |
613bbd7c | 577 | } |
578 | ||
613bbd7c | 579 | /** |
05226d76 | 580 | * @deprecated use is_enrolled($context, $userid) instead. |
613bbd7c | 581 | */ |
4f0c2d00 | 582 | function is_course_participant($userid, $courseid) { |
e4d9185e | 583 | throw new coding_exception('is_course_participant() can not be used any more, use is_enrolled() instead.'); |
613bbd7c | 584 | } |
585 | ||
586 | /** | |
1ac1d29b | 587 | * @deprecated |
613bbd7c | 588 | */ |
589 | function get_recent_enrolments($courseid, $timestart) { | |
2149326b | 590 | throw new coding_exception('get_recent_enrolments() is removed as it returned inaccurate results.'); |
613bbd7c | 591 | } |
592 | ||
ed5dd29f | 593 | /** |
05226d76 | 594 | * @deprecated use clean_param($string, PARAM_FILE) instead. |
ed5dd29f | 595 | */ |
596 | function detect_munged_arguments($string, $allowdots=1) { | |
e4d9185e | 597 | throw new coding_exception('detect_munged_arguments() can not be used any more, please use clean_param(,PARAM_FILE) instead.'); |
ed5dd29f | 598 | } |
599 | ||
9152fc99 | 600 | |
0c6d2dd4 | 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. | |
c861fe2f | 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 | |
2c2f4f17 | 611 | * @deprecated since 2.0 MDL-15919 |
0c6d2dd4 | 612 | */ |
613 | function unzip_file($zipfile, $destination = '', $showstatus_ignored = true) { | |
2c2f4f17 AN |
614 | debugging(__FUNCTION__ . '() is deprecated. ' |
615 | . 'Please use the application/zip file_packer implementation instead.', DEBUG_DEVELOPER); | |
0c6d2dd4 | 616 | |
2c2f4f17 | 617 | // Extract everything from zipfile. |
0c6d2dd4 | 618 | $path_parts = pathinfo(cleardoubleslashes($zipfile)); |
619 | $zippath = $path_parts["dirname"]; //The path of the zip file | |
620 | $zipfilename = $path_parts["basename"]; //The name of the zip file | |
621 | $extension = $path_parts["extension"]; //The extension of the file | |
622 | ||
623 | //If no file, error | |
624 | if (empty($zipfilename)) { | |
625 | return false; | |
626 | } | |
627 | ||
628 | //If no extension, error | |
629 | if (empty($extension)) { | |
630 | return false; | |
631 | } | |
632 | ||
633 | //Clear $zipfile | |
634 | $zipfile = cleardoubleslashes($zipfile); | |
635 | ||
636 | //Check zipfile exists | |
637 | if (!file_exists($zipfile)) { | |
638 | return false; | |
639 | } | |
640 | ||
641 | //If no destination, passed let's go with the same directory | |
642 | if (empty($destination)) { | |
643 | $destination = $zippath; | |
644 | } | |
645 | ||
646 | //Clear $destination | |
647 | $destpath = rtrim(cleardoubleslashes($destination), "/"); | |
648 | ||
649 | //Check destination path exists | |
650 | if (!is_dir($destpath)) { | |
651 | return false; | |
652 | } | |
653 | ||
0b0bfa93 | 654 | $packer = get_file_packer('application/zip'); |
655 | ||
656 | $result = $packer->extract_to_pathname($zipfile, $destpath); | |
0c6d2dd4 | 657 | |
658 | if ($result === false) { | |
659 | return false; | |
660 | } | |
661 | ||
662 | foreach ($result as $status) { | |
663 | if ($status !== true) { | |
664 | return false; | |
665 | } | |
666 | } | |
667 | ||
668 | return true; | |
669 | } | |
670 | ||
ed94cb66 | 671 | /** |
672 | * Zip an array of files/dirs to a destination zip file | |
673 | * Both parameters must be FULL paths to the files/dirs | |
c861fe2f | 674 | * |
675 | * @global object | |
676 | * @param array $originalfiles Files to zip | |
677 | * @param string $destination The destination path | |
678 | * @return bool Outcome | |
56b9e796 AN |
679 | * |
680 | * @deprecated since 2.0 MDL-15919 | |
ed94cb66 | 681 | */ |
56b9e796 AN |
682 | function zip_files($originalfiles, $destination) { |
683 | debugging(__FUNCTION__ . '() is deprecated. ' | |
684 | . 'Please use the application/zip file_packer implementation instead.', DEBUG_DEVELOPER); | |
ed94cb66 | 685 | |
56b9e796 | 686 | // Extract everything from destination. |
ed94cb66 | 687 | $path_parts = pathinfo(cleardoubleslashes($destination)); |
688 | $destpath = $path_parts["dirname"]; //The path of the zip file | |
689 | $destfilename = $path_parts["basename"]; //The name of the zip file | |
690 | $extension = $path_parts["extension"]; //The extension of the file | |
691 | ||
692 | //If no file, error | |
693 | if (empty($destfilename)) { | |
694 | return false; | |
695 | } | |
696 | ||
697 | //If no extension, add it | |
698 | if (empty($extension)) { | |
699 | $extension = 'zip'; | |
700 | $destfilename = $destfilename.'.'.$extension; | |
701 | } | |
702 | ||
703 | //Check destination path exists | |
704 | if (!is_dir($destpath)) { | |
705 | return false; | |
706 | } | |
707 | ||
708 | //Check destination path is writable. TODO!! | |
709 | ||
710 | //Clean destination filename | |
711 | $destfilename = clean_filename($destfilename); | |
712 | ||
713 | //Now check and prepare every file | |
714 | $files = array(); | |
715 | $origpath = NULL; | |
716 | ||
717 | foreach ($originalfiles as $file) { //Iterate over each file | |
718 | //Check for every file | |
719 | $tempfile = cleardoubleslashes($file); // no doubleslashes! | |
720 | //Calculate the base path for all files if it isn't set | |
721 | if ($origpath === NULL) { | |
722 | $origpath = rtrim(cleardoubleslashes(dirname($tempfile)), "/"); | |
723 | } | |
724 | //See if the file is readable | |
725 | if (!is_readable($tempfile)) { //Is readable | |
726 | continue; | |
727 | } | |
728 | //See if the file/dir is in the same directory than the rest | |
729 | if (rtrim(cleardoubleslashes(dirname($tempfile)), "/") != $origpath) { | |
730 | continue; | |
731 | } | |
732 | //Add the file to the array | |
733 | $files[] = $tempfile; | |
734 | } | |
735 | ||
736 | $zipfiles = array(); | |
737 | $start = strlen($origpath)+1; | |
738 | foreach($files as $file) { | |
739 | $zipfiles[substr($file, $start)] = $file; | |
740 | } | |
741 | ||
0b0bfa93 | 742 | $packer = get_file_packer('application/zip'); |
ed94cb66 | 743 | |
3ed22f1a | 744 | return $packer->archive_to_pathname($zipfiles, $destpath . '/' . $destfilename); |
ed94cb66 | 745 | } |
746 | ||
5bf243d1 | 747 | /** |
05226d76 | 748 | * @deprecated use groups_get_all_groups() instead. |
5bf243d1 | 749 | */ |
750 | function mygroupid($courseid) { | |
e4d9185e | 751 | throw new coding_exception('mygroupid() can not be used any more, please use groups_get_all_groups() instead.'); |
5bf243d1 | 752 | } |
753 | ||
5bf243d1 | 754 | |
5bf243d1 | 755 | /** |
756 | * Returns the current group mode for a given course or activity module | |
364fffda | 757 | * |
5bf243d1 | 758 | * Could be false, SEPARATEGROUPS or VISIBLEGROUPS (<-- Martin) |
c861fe2f | 759 | * |
d494100e AA |
760 | * @deprecated since Moodle 2.0 MDL-14617 - please do not use this function any more. |
761 | * @todo MDL-50273 This will be deleted in Moodle 3.2. | |
762 | * | |
c861fe2f | 763 | * @param object $course Course Object |
764 | * @param object $cm Course Manager Object | |
765 | * @return mixed $course->groupmode | |
5bf243d1 | 766 | */ |
767 | function groupmode($course, $cm=null) { | |
768 | ||
d494100e | 769 | debugging('groupmode() is deprecated, please use groups_get_* instead', DEBUG_DEVELOPER); |
5bf243d1 | 770 | if (isset($cm->groupmode) && empty($course->groupmodeforce)) { |
771 | return $cm->groupmode; | |
772 | } | |
773 | return $course->groupmode; | |
774 | } | |
775 | ||
c584346c | 776 | /** |
777 | * Sets the current group in the session variable | |
778 | * When $SESSION->currentgroup[$courseid] is set to 0 it means, show all groups. | |
779 | * Sets currentgroup[$courseid] in the session variable appropriately. | |
780 | * Does not do any permission checking. | |
c861fe2f | 781 | * |
d494100e AA |
782 | * @deprecated Since year 2006 - please do not use this function any more. |
783 | * @todo MDL-50273 This will be deleted in Moodle 3.2. | |
784 | * | |
c861fe2f | 785 | * @global object |
2149326b | 786 | * @global object |
c584346c | 787 | * @param int $courseid The course being examined - relates to id field in |
788 | * 'course' table. | |
789 | * @param int $groupid The group being examined. | |
790 | * @return int Current group id which was set by this function | |
791 | */ | |
792 | function set_current_group($courseid, $groupid) { | |
793 | global $SESSION; | |
d494100e AA |
794 | |
795 | debugging('set_current_group() is deprecated, please use $SESSION->currentgroup[$courseid] instead', DEBUG_DEVELOPER); | |
c584346c | 796 | return $SESSION->currentgroup[$courseid] = $groupid; |
797 | } | |
798 | ||
5bf243d1 | 799 | /** |
364fffda | 800 | * Gets the current group - either from the session variable or from the database. |
5bf243d1 | 801 | * |
d494100e AA |
802 | * @deprecated Since year 2006 - please do not use this function any more. |
803 | * @todo MDL-50273 This will be deleted in Moodle 3.2. | |
804 | * | |
c861fe2f | 805 | * @global object |
364fffda | 806 | * @param int $courseid The course being examined - relates to id field in |
5bf243d1 | 807 | * 'course' table. |
364fffda | 808 | * @param bool $full If true, the return value is a full record object. |
5bf243d1 | 809 | * If false, just the id of the record. |
c861fe2f | 810 | * @return int|bool |
5bf243d1 | 811 | */ |
812 | function get_current_group($courseid, $full = false) { | |
813 | global $SESSION; | |
814 | ||
d494100e | 815 | debugging('get_current_group() is deprecated, please use groups_get_* instead', DEBUG_DEVELOPER); |
5bf243d1 | 816 | if (isset($SESSION->currentgroup[$courseid])) { |
817 | if ($full) { | |
818 | return groups_get_group($SESSION->currentgroup[$courseid]); | |
819 | } else { | |
820 | return $SESSION->currentgroup[$courseid]; | |
821 | } | |
822 | } | |
823 | ||
824 | $mygroupid = mygroupid($courseid); | |
825 | if (is_array($mygroupid)) { | |
826 | $mygroupid = array_shift($mygroupid); | |
827 | set_current_group($courseid, $mygroupid); | |
828 | if ($full) { | |
829 | return groups_get_group($mygroupid); | |
830 | } else { | |
831 | return $mygroupid; | |
832 | } | |
833 | } | |
834 | ||
835 | if ($full) { | |
836 | return false; | |
837 | } else { | |
838 | return 0; | |
839 | } | |
840 | } | |
841 | ||
061e6b28 | 842 | /** |
061e6b28 | 843 | * @deprecated Since Moodle 2.8 |
844 | */ | |
845 | function groups_filter_users_by_course_module_visible($cm, $users) { | |
2149326b | 846 | throw new coding_exception('groups_filter_users_by_course_module_visible() is removed. ' . |
061e6b28 | 847 | 'Replace with a call to \core_availability\info_module::filter_user_list(), ' . |
848 | 'which does basically the same thing but includes other restrictions such ' . | |
1ac1d29b | 849 | 'as profile restrictions.'); |
061e6b28 | 850 | } |
851 | ||
852 | /** | |
061e6b28 | 853 | * @deprecated Since Moodle 2.8 |
854 | */ | |
855 | function groups_course_module_visible($cm, $userid=null) { | |
2149326b AA |
856 | throw new coding_exception('groups_course_module_visible() is removed, use $cm->uservisible to decide whether the current |
857 | user can ' . 'access an activity.', DEBUG_DEVELOPER); | |
061e6b28 | 858 | } |
5bf243d1 | 859 | |
8ec50604 | 860 | /** |
1ac1d29b | 861 | * @deprecated since 2.0 |
8ec50604 | 862 | */ |
245ac557 | 863 | function error($message, $link='') { |
2149326b | 864 | throw new coding_exception('notlocalisederrormessage', 'error', $link, $message, 'error() is a removed, please call |
1ac1d29b | 865 | print_error() instead of error()'); |
251387d0 | 866 | } |
8ec50604 | 867 | |
8ec50604 | 868 | |
b7009474 | 869 | /** |
870 | * @deprecated use $PAGE->theme->name instead. | |
b7009474 | 871 | */ |
872 | function current_theme() { | |
e4d9185e | 873 | throw new coding_exception('current_theme() can not be used any more, please use $PAGE->theme->name instead'); |
b7009474 | 874 | } |
875 | ||
8954245a | 876 | /** |
8954245a | 877 | * @deprecated |
8954245a | 878 | */ |
879 | function formerr($error) { | |
2149326b | 880 | throw new coding_exception('formerr() is removed. Please change your code to use $OUTPUT->error_text($string).'); |
8954245a | 881 | } |
882 | ||
34a2777c | 883 | /** |
34a2777c | 884 | * @deprecated use $OUTPUT->skip_link_target() in instead. |
34a2777c | 885 | */ |
886 | function skip_main_destination() { | |
e4d9185e | 887 | throw new coding_exception('skip_main_destination() can not be used any more, please use $OUTPUT->skip_link_target() instead.'); |
34a2777c | 888 | } |
889 | ||
34a2777c | 890 | /** |
05226d76 | 891 | * @deprecated use $OUTPUT->container() instead. |
34a2777c | 892 | */ |
893 | function print_container($message, $clearfix=false, $classes='', $idbase='', $return=false) { | |
e4d9185e | 894 | throw new coding_exception('print_container() can not be used any more. Please use $OUTPUT->container() instead.'); |
34a2777c | 895 | } |
896 | ||
897 | /** | |
05226d76 | 898 | * @deprecated use $OUTPUT->container_start() instead. |
34a2777c | 899 | */ |
900 | function print_container_start($clearfix=false, $classes='', $idbase='', $return=false) { | |
e4d9185e | 901 | throw new coding_exception('print_container_start() can not be used any more. Please use $OUTPUT->container_start() instead.'); |
34a2777c | 902 | } |
903 | ||
904 | /** | |
05226d76 | 905 | * @deprecated use $OUTPUT->container_end() instead. |
34a2777c | 906 | */ |
907 | function print_container_end($return=false) { | |
e4d9185e | 908 | throw new coding_exception('print_container_end() can not be used any more. Please use $OUTPUT->container_end() instead.'); |
34a2777c | 909 | } |
910 | ||
911 | /** | |
912 | * Print a bold message in an optional color. | |
913 | * | |
ef53650e | 914 | * @deprecated since Moodle 2.0 MDL-19077 - use $OUTPUT->notification instead. |
c917b53a | 915 | * @todo MDL-50469 This will be deleted in Moodle 3.3. |
34a2777c | 916 | * @param string $message The message to print out |
c917b53a | 917 | * @param string $classes Optional style to display message text in |
34a2777c | 918 | * @param string $align Alignment option |
919 | * @param bool $return whether to return an output string or echo now | |
a5cb8d69 | 920 | * @return string|bool Depending on $result |
34a2777c | 921 | */ |
24346803 | 922 | function notify($message, $classes = 'error', $align = 'center', $return = false) { |
34a2777c | 923 | global $OUTPUT; |
924 | ||
c917b53a AA |
925 | debugging('notify() is deprecated, please use $OUTPUT->notification() instead', DEBUG_DEVELOPER); |
926 | ||
34a2777c | 927 | if ($classes == 'green') { |
24346803 AN |
928 | debugging('Use of deprecated class name "green" in notify. Please change to "success".', DEBUG_DEVELOPER); |
929 | $classes = 'success'; // Backward compatible with old color system. | |
34a2777c | 930 | } |
931 | ||
932 | $output = $OUTPUT->notification($message, $classes); | |
933 | if ($return) { | |
934 | return $output; | |
935 | } else { | |
936 | echo $output; | |
937 | } | |
938 | } | |
939 | ||
940 | /** | |
05226d76 | 941 | * @deprecated use $OUTPUT->continue_button() instead. |
34a2777c | 942 | */ |
943 | function print_continue($link, $return = false) { | |
e4d9185e | 944 | throw new coding_exception('print_continue() can not be used any more. Please use $OUTPUT->continue_button() instead.'); |
34a2777c | 945 | } |
946 | ||
34a2777c | 947 | /** |
05226d76 | 948 | * @deprecated use $PAGE methods instead. |
34a2777c | 949 | */ |
950 | function print_header($title='', $heading='', $navigation='', $focus='', | |
e120c61d | 951 | $meta='', $cache=true, $button=' ', $menu=null, |
34a2777c | 952 | $usexml=false, $bodytags='', $return=false) { |
34a2777c | 953 | |
e4d9185e | 954 | throw new coding_exception('print_header() can not be used any more. Please use $PAGE methods instead.'); |
34a2777c | 955 | } |
956 | ||
47a1aa45 | 957 | /** |
05226d76 | 958 | * @deprecated use $PAGE methods instead. |
47a1aa45 | 959 | */ |
960 | function print_header_simple($title='', $heading='', $navigation='', $focus='', $meta='', | |
961 | $cache=true, $button=' ', $menu='', $usexml=false, $bodytags='', $return=false) { | |
962 | ||
e4d9185e | 963 | throw new coding_exception('print_header_simple() can not be used any more. Please use $PAGE methods instead.'); |
47a1aa45 | 964 | } |
965 | ||
a5cb8d69 | 966 | /** |
05226d76 | 967 | * @deprecated use $OUTPUT->block() instead. |
a5cb8d69 | 968 | */ |
969 | function print_side_block($heading='', $content='', $list=NULL, $icons=NULL, $footer='', $attributes = array(), $title='') { | |
e4d9185e | 970 | throw new coding_exception('print_side_block() can not be used any more, please use $OUTPUT->block() instead.'); |
a5cb8d69 | 971 | } |
972 | ||
f8065dd2 | 973 | /** |
974 | * Prints a basic textarea field. | |
975 | * | |
976 | * @deprecated since Moodle 2.0 | |
977 | * | |
978 | * When using this function, you should | |
979 | * | |
980 | * @global object | |
3d27180e | 981 | * @param bool $unused No longer used. |
f8065dd2 | 982 | * @param int $rows Number of rows to display (minimum of 10 when $height is non-null) |
983 | * @param int $cols Number of columns to display (minimum of 65 when $width is non-null) | |
984 | * @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. | |
985 | * @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. | |
986 | * @param string $name Name to use for the textarea element. | |
987 | * @param string $value Initial content to display in the textarea. | |
988 | * @param int $obsolete deprecated | |
989 | * @param bool $return If false, will output string. If true, will return string value. | |
990 | * @param string $id CSS ID to add to the textarea element. | |
991 | * @return string|void depending on the value of $return | |
992 | */ | |
3d27180e | 993 | function print_textarea($unused, $rows, $cols, $width, $height, $name, $value='', $obsolete=0, $return=false, $id='') { |
f8065dd2 | 994 | /// $width and height are legacy fields and no longer used as pixels like they used to be. |
995 | /// However, you can set them to zero to override the mincols and minrows values below. | |
996 | ||
3d8a479b MD |
997 | // Disabling because there is not yet a viable $OUTPUT option for cases when mforms can't be used |
998 | // debugging('print_textarea() has been deprecated. You should be using mforms and the editor element.'); | |
f8065dd2 | 999 | |
1000 | global $CFG; | |
1001 | ||
1002 | $mincols = 65; | |
1003 | $minrows = 10; | |
1004 | $str = ''; | |
1005 | ||
1006 | if ($id === '') { | |
1007 | $id = 'edit-'.$name; | |
1008 | } | |
1009 | ||
3d27180e DW |
1010 | if ($height && ($rows < $minrows)) { |
1011 | $rows = $minrows; | |
f8065dd2 | 1012 | } |
3d27180e DW |
1013 | if ($width && ($cols < $mincols)) { |
1014 | $cols = $mincols; | |
f8065dd2 | 1015 | } |
1016 | ||
3d27180e DW |
1017 | editors_head_setup(); |
1018 | $editor = editors_get_preferred_editor(FORMAT_HTML); | |
988592c5 | 1019 | $editor->set_text($value); |
3d27180e DW |
1020 | $editor->use_editor($id, array('legacy'=>true)); |
1021 | ||
0ac97084 | 1022 | $str .= "\n".'<textarea class="form-textarea" id="'. $id .'" name="'. $name .'" rows="'. $rows .'" cols="'. $cols .'" spellcheck="true">'."\n"; |
3d27180e | 1023 | $str .= htmlspecialchars($value); // needed for editing of cleaned text! |
f8065dd2 | 1024 | $str .= '</textarea>'."\n"; |
1025 | ||
1026 | if ($return) { | |
1027 | return $str; | |
1028 | } | |
1029 | echo $str; | |
1030 | } | |
1031 | ||
f8065dd2 | 1032 | /** |
1033 | * Returns an image of an up or down arrow, used for column sorting. To avoid unnecessary DB accesses, please | |
1034 | * provide this function with the language strings for sortasc and sortdesc. | |
1035 | * | |
05226d76 | 1036 | * @deprecated use $OUTPUT->arrow() instead. |
e4d9185e | 1037 | * @todo final deprecation of this function once MDL-45448 is resolved |
f8065dd2 | 1038 | * |
f8065dd2 | 1039 | * If no sort string is associated with the direction, an arrow with no alt text will be printed/returned. |
1040 | * | |
1041 | * @global object | |
1042 | * @param string $direction 'up' or 'down' | |
1043 | * @param string $strsort The language string used for the alt attribute of this image | |
1044 | * @param bool $return Whether to print directly or return the html string | |
1045 | * @return string|void depending on $return | |
1046 | * | |
1047 | */ | |
1048 | function print_arrow($direction='up', $strsort=null, $return=false) { | |
f8065dd2 | 1049 | global $OUTPUT; |
1050 | ||
05226d76 DP |
1051 | debugging('print_arrow() is deprecated. Please use $OUTPUT->arrow() instead.', DEBUG_DEVELOPER); |
1052 | ||
f8065dd2 | 1053 | if (!in_array($direction, array('up', 'down', 'right', 'left', 'move'))) { |
1054 | return null; | |
1055 | } | |
1056 | ||
1057 | $return = null; | |
1058 | ||
1059 | switch ($direction) { | |
1060 | case 'up': | |
1061 | $sortdir = 'asc'; | |
1062 | break; | |
1063 | case 'down': | |
1064 | $sortdir = 'desc'; | |
1065 | break; | |
1066 | case 'move': | |
1067 | $sortdir = 'asc'; | |
1068 | break; | |
1069 | default: | |
1070 | $sortdir = null; | |
1071 | break; | |
1072 | } | |
1073 | ||
1074 | // Prepare language string | |
1075 | $strsort = ''; | |
1076 | if (empty($strsort) && !empty($sortdir)) { | |
1077 | $strsort = get_string('sort' . $sortdir, 'grades'); | |
1078 | } | |
1079 | ||
b5d0cafc | 1080 | $return = ' <img src="'.$OUTPUT->pix_url('t/' . $direction) . '" alt="'.$strsort.'" /> '; |
f8065dd2 | 1081 | |
1082 | if ($return) { | |
1083 | return $return; | |
1084 | } else { | |
1085 | echo $return; | |
1086 | } | |
1087 | } | |
1088 | ||
8100c169 | 1089 | /** |
8100c169 | 1090 | * @deprecated since Moodle 2.0 |
8100c169 | 1091 | */ |
1092 | function choose_from_menu ($options, $name, $selected='', $nothing='choose', $script='', | |
1093 | $nothingvalue='0', $return=false, $disabled=false, $tabindex=0, | |
1094 | $id='', $listbox=false, $multiple=false, $class='') { | |
2149326b | 1095 | throw new coding_exception('choose_from_menu() is removed. Please change your code to use html_writer::select().'); |
053203a8 | 1096 | |
053203a8 | 1097 | } |
1098 | ||
c68e4098 | 1099 | /** |
05226d76 | 1100 | * @deprecated use $OUTPUT->help_icon_scale($courseid, $scale) instead. |
c68e4098 | 1101 | */ |
1102 | function print_scale_menu_helpbutton($courseid, $scale, $return=false) { | |
e4d9185e DP |
1103 | throw new coding_exception('print_scale_menu_helpbutton() can not be used any more. '. |
1104 | 'Please use $OUTPUT->help_icon_scale($courseid, $scale) instead.'); | |
c68e4098 | 1105 | } |
1106 | ||
49c8c8d2 | 1107 | /** |
05226d76 | 1108 | * @deprecated use html_writer::checkbox() instead. |
49c8c8d2 | 1109 | */ |
916276fc | 1110 | function print_checkbox($name, $value, $checked = true, $label = '', $alt = '', $script='', $return=false) { |
e4d9185e | 1111 | throw new coding_exception('print_checkbox() can not be used any more. Please use html_writer::checkbox() instead.'); |
49c8c8d2 | 1112 | } |
6a5c71b9 | 1113 | |
d3932d2b JP |
1114 | /** |
1115 | * Prints the 'update this xxx' button that appears on module pages. | |
1116 | * | |
1117 | * @deprecated since Moodle 3.2 | |
1118 | * | |
1119 | * @param string $cmid the course_module id. | |
1120 | * @param string $ignored not used any more. (Used to be courseid.) | |
1121 | * @param string $string the module name - get_string('modulename', 'xxx') | |
1122 | * @return string the HTML for the button, if this user has permission to edit it, else an empty string. | |
1123 | */ | |
1124 | function update_module_button($cmid, $ignored, $string) { | |
1125 | global $CFG, $OUTPUT; | |
1126 | ||
1127 | debugging('update_module_button() has been deprecated and should not be used anymore. Activity modules should not add the ' . | |
1128 | 'edit module button, the link is already available in the Administration block. Themes can choose to display the link ' . | |
1129 | 'in the buttons row consistently for all module types.', DEBUG_DEVELOPER); | |
1130 | ||
1131 | if (has_capability('moodle/course:manageactivities', context_module::instance($cmid))) { | |
1132 | $string = get_string('updatethis', '', $string); | |
1133 | ||
1134 | $url = new moodle_url("$CFG->wwwroot/course/mod.php", array('update' => $cmid, 'return' => true, 'sesskey' => sesskey())); | |
1135 | return $OUTPUT->single_button($url, $string); | |
1136 | } else { | |
1137 | return ''; | |
1138 | } | |
1139 | } | |
1140 | ||
7d2a0492 | 1141 | /** |
05226d76 | 1142 | * @deprecated use $OUTPUT->navbar() instead |
7d2a0492 | 1143 | */ |
1144 | function print_navigation ($navigation, $separator=0, $return=false) { | |
e4d9185e | 1145 | throw new coding_exception('print_navigation() can not be used any more, please update use $OUTPUT->navbar() instead.'); |
7d2a0492 | 1146 | } |
1147 | ||
1148 | /** | |
05226d76 | 1149 | * @deprecated Please use $PAGE->navabar methods instead. |
7d2a0492 | 1150 | */ |
1151 | function build_navigation($extranavlinks, $cm = null) { | |
e4d9185e | 1152 | throw new coding_exception('build_navigation() can not be used any more, please use $PAGE->navbar methods instead.'); |
7d2a0492 | 1153 | } |
1154 | ||
1155 | /** | |
05226d76 | 1156 | * @deprecated not relevant with global navigation in Moodle 2.x+ |
7d2a0492 | 1157 | */ |
1158 | function navmenu($course, $cm=NULL, $targetwindow='self') { | |
e4d9185e | 1159 | throw new coding_exception('navmenu() can not be used any more, it is no longer relevant with global navigation.'); |
f43cdceb | 1160 | } |
76d9df3f SH |
1161 | |
1162 | /// CALENDAR MANAGEMENT //////////////////////////////////////////////////////////////// | |
1163 | ||
1164 | ||
1165 | /** | |
05226d76 | 1166 | * @deprecated please use calendar_event::create() instead. |
76d9df3f | 1167 | */ |
34c6ec18 | 1168 | function add_event($event) { |
e4d9185e | 1169 | throw new coding_exception('add_event() can not be used any more, please use calendar_event::create() instead.'); |
76d9df3f SH |
1170 | } |
1171 | ||
1172 | /** | |
05226d76 | 1173 | * @deprecated please calendar_event->update() instead. |
76d9df3f SH |
1174 | */ |
1175 | function update_event($event) { | |
2149326b | 1176 | throw new coding_exception('update_event() is removed, please use calendar_event->update() instead.'); |
76d9df3f SH |
1177 | } |
1178 | ||
1179 | /** | |
05226d76 | 1180 | * @deprecated please use calendar_event->delete() instead. |
76d9df3f SH |
1181 | */ |
1182 | function delete_event($id) { | |
e4d9185e DP |
1183 | throw new coding_exception('delete_event() can not be used any more, please use '. |
1184 | 'calendar_event->delete() instead.'); | |
76d9df3f SH |
1185 | } |
1186 | ||
1187 | /** | |
05226d76 | 1188 | * @deprecated please use calendar_event->toggle_visibility(false) instead. |
76d9df3f SH |
1189 | */ |
1190 | function hide_event($event) { | |
e4d9185e DP |
1191 | throw new coding_exception('hide_event() can not be used any more, please use '. |
1192 | 'calendar_event->toggle_visibility(false) instead.'); | |
76d9df3f SH |
1193 | } |
1194 | ||
1195 | /** | |
05226d76 | 1196 | * @deprecated please use calendar_event->toggle_visibility(true) instead. |
76d9df3f SH |
1197 | */ |
1198 | function show_event($event) { | |
e4d9185e DP |
1199 | throw new coding_exception('show_event() can not be used any more, please use '. |
1200 | 'calendar_event->toggle_visibility(true) instead.'); | |
0189bf77 | 1201 | } |
6f3451e5 | 1202 | |
3fed29a7 | 1203 | /** |
6b61c2c4 FM |
1204 | * @deprecated since Moodle 2.2 use core_text::xxxx() instead. |
1205 | * @see core_text | |
3fed29a7 PS |
1206 | */ |
1207 | function textlib_get_instance() { | |
6b61c2c4 FM |
1208 | throw new coding_exception('textlib_get_instance() can not be used any more, please use '. |
1209 | 'core_text::functioname() instead.'); | |
3fed29a7 PS |
1210 | } |
1211 | ||
ee7084e9 | 1212 | /** |
ee7084e9 MG |
1213 | * @deprecated since 2.4 |
1214 | * @see get_section_name() | |
1215 | * @see format_base::get_section_name() | |
1ac1d29b | 1216 | |
ee7084e9 MG |
1217 | */ |
1218 | function get_generic_section_name($format, stdClass $section) { | |
1ac1d29b | 1219 | throw new coding_exception('get_generic_section_name() is deprecated. Please use appropriate functionality from class format_base'); |
ee7084e9 | 1220 | } |
99e9f9a6 MG |
1221 | |
1222 | /** | |
1223 | * Returns an array of sections for the requested course id | |
1224 | * | |
1225 | * It is usually not recommended to display the list of sections used | |
1226 | * in course because the course format may have it's own way to do it. | |
1227 | * | |
1228 | * If you need to just display the name of the section please call: | |
1229 | * get_section_name($course, $section) | |
1230 | * {@link get_section_name()} | |
1231 | * from 2.4 $section may also be just the field course_sections.section | |
1232 | * | |
1233 | * If you need the list of all sections it is more efficient to get this data by calling | |
b46be6ad | 1234 | * $modinfo = get_fast_modinfo($courseorid); |
99e9f9a6 MG |
1235 | * $sections = $modinfo->get_section_info_all() |
1236 | * {@link get_fast_modinfo()} | |
1237 | * {@link course_modinfo::get_section_info_all()} | |
1238 | * | |
1239 | * Information about one section (instance of section_info): | |
b46be6ad | 1240 | * get_fast_modinfo($courseorid)->get_sections_info($section) |
99e9f9a6 MG |
1241 | * {@link course_modinfo::get_section_info()} |
1242 | * | |
1243 | * @deprecated since 2.4 | |
99e9f9a6 MG |
1244 | */ |
1245 | function get_all_sections($courseid) { | |
1ac1d29b | 1246 | |
2149326b | 1247 | throw new coding_exception('get_all_sections() is removed. See phpdocs for this function'); |
99e9f9a6 | 1248 | } |
722e6ba9 MG |
1249 | |
1250 | /** | |
722e6ba9 MG |
1251 | * This function is deprecated, please use {@link course_add_cm_to_section()} |
1252 | * Note that course_add_cm_to_section() also updates field course_modules.section and | |
1253 | * calls rebuild_course_cache() | |
1254 | * | |
1255 | * @deprecated since 2.4 | |
722e6ba9 | 1256 | */ |
44aa854e | 1257 | function add_mod_to_section($mod, $beforemod = null) { |
2149326b | 1258 | throw new coding_exception('Function add_mod_to_section() is removed, please use course_add_cm_to_section()'); |
722e6ba9 | 1259 | } |
d57aa283 MG |
1260 | |
1261 | /** | |
1262 | * Returns a number of useful structures for course displays | |
1263 | * | |
1264 | * Function get_all_mods() is deprecated in 2.4 | |
1265 | * Instead of: | |
1266 | * <code> | |
b46be6ad | 1267 | * get_all_mods($courseid, $mods, $modnames, $modnamesplural, $modnamesused); |
d57aa283 MG |
1268 | * </code> |
1269 | * please use: | |
1270 | * <code> | |
b46be6ad | 1271 | * $mods = get_fast_modinfo($courseorid)->get_cms(); |
d57aa283 MG |
1272 | * $modnames = get_module_types_names(); |
1273 | * $modnamesplural = get_module_types_names(true); | |
b46be6ad | 1274 | * $modnamesused = get_fast_modinfo($courseorid)->get_used_module_names(); |
d57aa283 MG |
1275 | * </code> |
1276 | * | |
1277 | * @deprecated since 2.4 | |
d57aa283 MG |
1278 | */ |
1279 | function get_all_mods($courseid, &$mods, &$modnames, &$modnamesplural, &$modnamesused) { | |
2149326b | 1280 | throw new coding_exception('Function get_all_mods() is removed. Use get_fast_modinfo() and get_module_types_names() instead. See phpdocs for details'); |
d57aa283 | 1281 | } |
4ede27b2 MG |
1282 | |
1283 | /** | |
1284 | * Returns course section - creates new if does not exist yet | |
1285 | * | |
1286 | * This function is deprecated. To create a course section call: | |
b46be6ad | 1287 | * course_create_sections_if_missing($courseorid, $sections); |
4ede27b2 | 1288 | * to get the section call: |
b46be6ad | 1289 | * get_fast_modinfo($courseorid)->get_section_info($sectionnum); |
4ede27b2 MG |
1290 | * |
1291 | * @see course_create_sections_if_missing() | |
1292 | * @see get_fast_modinfo() | |
1293 | * @deprecated since 2.4 | |
4ede27b2 MG |
1294 | */ |
1295 | function get_course_section($section, $courseid) { | |
2149326b | 1296 | throw new coding_exception('Function get_course_section() is removed. Please use course_create_sections_if_missing() and get_fast_modinfo() instead.'); |
4ede27b2 | 1297 | } |
1b2581f4 MG |
1298 | |
1299 | /** | |
1b2581f4 MG |
1300 | * @deprecated since 2.4 |
1301 | * @see format_weeks::get_section_dates() | |
1b2581f4 MG |
1302 | */ |
1303 | function format_weeks_get_section_dates($section, $course) { | |
2149326b | 1304 | throw new coding_exception('Function format_weeks_get_section_dates() is removed. It is not recommended to'. |
1ac1d29b | 1305 | ' use it outside of format_weeks plugin'); |
1b2581f4 | 1306 | } |
9a36be73 MG |
1307 | |
1308 | /** | |
9a36be73 MG |
1309 | * Deprecated. Instead of: |
1310 | * list($content, $name) = get_print_section_cm_text($cm, $course); | |
1311 | * use: | |
1312 | * $content = $cm->get_formatted_content(array('overflowdiv' => true, 'noclean' => true)); | |
1313 | * $name = $cm->get_formatted_name(); | |
1314 | * | |
1315 | * @deprecated since 2.5 | |
1316 | * @see cm_info::get_formatted_content() | |
1317 | * @see cm_info::get_formatted_name() | |
9a36be73 MG |
1318 | */ |
1319 | function get_print_section_cm_text(cm_info $cm, $course) { | |
2149326b | 1320 | throw new coding_exception('Function get_print_section_cm_text() is removed. Please use '. |
1ac1d29b | 1321 | 'cm_info::get_formatted_content() and cm_info::get_formatted_name()'); |
9a36be73 MG |
1322 | } |
1323 | ||
1324 | /** | |
9a36be73 MG |
1325 | * Deprecated. Please use: |
1326 | * $courserenderer = $PAGE->get_renderer('core', 'course'); | |
1327 | * $output = $courserenderer->course_section_add_cm_control($course, $section, $sectionreturn, | |
1328 | * array('inblock' => $vertical)); | |
188458a6 | 1329 | * echo $output; |
9a36be73 MG |
1330 | * |
1331 | * @deprecated since 2.5 | |
1332 | * @see core_course_renderer::course_section_add_cm_control() | |
9a36be73 MG |
1333 | */ |
1334 | function print_section_add_menus($course, $section, $modnames = null, $vertical=false, $return=false, $sectionreturn=null) { | |
2149326b | 1335 | throw new coding_exception('Function print_section_add_menus() is removed. Please use course renderer '. |
1ac1d29b | 1336 | 'function course_section_add_cm_control()'); |
9a36be73 MG |
1337 | } |
1338 | ||
1339 | /** | |
9a36be73 MG |
1340 | * Deprecated. Please use: |
1341 | * $courserenderer = $PAGE->get_renderer('core', 'course'); | |
1342 | * $actions = course_get_cm_edit_actions($mod, $indent, $section); | |
1343 | * return ' ' . $courserenderer->course_section_cm_edit_actions($actions); | |
1344 | * | |
1345 | * @deprecated since 2.5 | |
1346 | * @see course_get_cm_edit_actions() | |
1347 | * @see core_course_renderer->course_section_cm_edit_actions() | |
9a36be73 MG |
1348 | */ |
1349 | function make_editing_buttons(stdClass $mod, $absolute_ignored = true, $moveselect = true, $indent=-1, $section=null) { | |
2149326b | 1350 | throw new coding_exception('Function make_editing_buttons() is removed, please see PHPdocs in '. |
1ac1d29b | 1351 | 'lib/deprecatedlib.php on how to replace it'); |
9a36be73 MG |
1352 | } |
1353 | ||
1354 | /** | |
9a36be73 MG |
1355 | * Deprecated. Please use: |
1356 | * $courserenderer = $PAGE->get_renderer('core', 'course'); | |
1357 | * echo $courserenderer->course_section_cm_list($course, $section, $sectionreturn, | |
1358 | * array('hidecompletion' => $hidecompletion)); | |
1359 | * | |
1360 | * @deprecated since 2.5 | |
1361 | * @see core_course_renderer::course_section_cm_list() | |
9a36be73 MG |
1362 | */ |
1363 | function print_section($course, $section, $mods, $modnamesused, $absolute=false, $width="100%", $hidecompletion=false, $sectionreturn=null) { | |
2149326b | 1364 | throw new coding_exception('Function print_section() is removed. Please use course renderer function '. |
1ac1d29b | 1365 | 'course_section_cm_list() instead.'); |
9a36be73 | 1366 | } |
00ba185d | 1367 | |
ff233851 | 1368 | /** |
ff233851 | 1369 | * @deprecated since 2.5 |
ff233851 MG |
1370 | */ |
1371 | function print_overview($courses, array $remote_courses=array()) { | |
2149326b | 1372 | throw new coding_exception('Function print_overview() is removed. Use block course_overview to display this information'); |
ff233851 | 1373 | } |
a3f66bde MG |
1374 | |
1375 | /** | |
a3f66bde | 1376 | * @deprecated since 2.5 |
a3f66bde MG |
1377 | */ |
1378 | function print_recent_activity($course) { | |
2149326b | 1379 | throw new coding_exception('Function print_recent_activity() is removed. It is not recommended to'. |
1ac1d29b | 1380 | ' use it outside of block_recent_activity'); |
a3f66bde | 1381 | } |
a347aee3 MN |
1382 | |
1383 | /** | |
a347aee3 | 1384 | * @deprecated since 2.5 |
a347aee3 MN |
1385 | */ |
1386 | function delete_course_module($id) { | |
2149326b | 1387 | throw new coding_exception('Function delete_course_module() is removed. Please use course_delete_module() instead.'); |
a347aee3 | 1388 | } |
2c49fb4c MG |
1389 | |
1390 | /** | |
2c49fb4c | 1391 | * @deprecated since 2.5 |
2c49fb4c MG |
1392 | */ |
1393 | function update_category_button($categoryid = 0) { | |
2149326b | 1394 | throw new coding_exception('Function update_category_button() is removed. Pages to view '. |
1ac1d29b | 1395 | 'and edit courses are now separate and no longer depend on editing mode.'); |
2c49fb4c | 1396 | } |
4e0b6025 MG |
1397 | |
1398 | /** | |
4e0b6025 MG |
1399 | * This function is deprecated! For list of categories use |
1400 | * coursecat::make_all_categories($requiredcapability, $excludeid, $separator) | |
1401 | * For parents of one particular category use | |
1402 | * coursecat::get($id)->get_parents() | |
1403 | * | |
1404 | * @deprecated since 2.5 | |
4e0b6025 MG |
1405 | */ |
1406 | function make_categories_list(&$list, &$parents, $requiredcapability = '', | |
1407 | $excludeid = 0, $category = NULL, $path = "") { | |
2149326b | 1408 | throw new coding_exception('Global function make_categories_list() is removed. Please use '. |
1ac1d29b | 1409 | 'coursecat::make_categories_list() and coursecat::get_parents()'); |
4e0b6025 | 1410 | } |
deb65ced MG |
1411 | |
1412 | /** | |
deb65ced | 1413 | * @deprecated since 2.5 |
deb65ced MG |
1414 | */ |
1415 | function category_delete_move($category, $newparentid, $showfeedback=true) { | |
2149326b | 1416 | throw new coding_exception('Function category_delete_move() is removed. Please use coursecat::delete_move() instead.'); |
deb65ced MG |
1417 | } |
1418 | ||
1419 | /** | |
deb65ced | 1420 | * @deprecated since 2.5 |
deb65ced MG |
1421 | */ |
1422 | function category_delete_full($category, $showfeedback=true) { | |
2149326b | 1423 | throw new coding_exception('Function category_delete_full() is removed. Please use coursecat::delete_full() instead.'); |
deb65ced | 1424 | } |
6e1d1ee0 MG |
1425 | |
1426 | /** | |
6e1d1ee0 MG |
1427 | * This function is deprecated. Please use |
1428 | * $coursecat = coursecat::get($category->id); | |
1429 | * if ($coursecat->can_change_parent($newparentcat->id)) { | |
1430 | * $coursecat->change_parent($newparentcat->id); | |
1431 | * } | |
1432 | * | |
1433 | * Alternatively you can use | |
1434 | * $coursecat->update(array('parent' => $newparentcat->id)); | |
1435 | * | |
6e1d1ee0 MG |
1436 | * @see coursecat::change_parent() |
1437 | * @see coursecat::update() | |
1438 | * @deprecated since 2.5 | |
6e1d1ee0 MG |
1439 | */ |
1440 | function move_category($category, $newparentcat) { | |
2149326b | 1441 | throw new coding_exception('Function move_category() is removed. Please use coursecat::change_parent() instead.'); |
6e1d1ee0 MG |
1442 | } |
1443 | ||
1444 | /** | |
6e1d1ee0 MG |
1445 | * This function is deprecated. Please use |
1446 | * coursecat::get($category->id)->hide(); | |
1447 | * | |
1448 | * @see coursecat::hide() | |
1449 | * @deprecated since 2.5 | |
6e1d1ee0 MG |
1450 | */ |
1451 | function course_category_hide($category) { | |
2149326b | 1452 | throw new coding_exception('Function course_category_hide() is removed. Please use coursecat::hide() instead.'); |
6e1d1ee0 MG |
1453 | } |
1454 | ||
1455 | /** | |
6e1d1ee0 MG |
1456 | * This function is deprecated. Please use |
1457 | * coursecat::get($category->id)->show(); | |
1458 | * | |
1459 | * @see coursecat::show() | |
1460 | * @deprecated since 2.5 | |
6e1d1ee0 MG |
1461 | */ |
1462 | function course_category_show($category) { | |
2149326b | 1463 | throw new coding_exception('Function course_category_show() is removed. Please use coursecat::show() instead.'); |
6e1d1ee0 | 1464 | } |
2d8a275b MG |
1465 | |
1466 | /** | |
2d8a275b MG |
1467 | * This function is deprecated. |
1468 | * To get the category with the specified it please use: | |
1469 | * coursecat::get($catid, IGNORE_MISSING); | |
1470 | * or | |
1471 | * coursecat::get($catid, MUST_EXIST); | |
1472 | * | |
1473 | * To get the first available category please use | |
1474 | * coursecat::get_default(); | |
1475 | * | |
2d8a275b | 1476 | * @deprecated since 2.5 |
2d8a275b MG |
1477 | */ |
1478 | function get_course_category($catid=0) { | |
2149326b | 1479 | throw new coding_exception('Function get_course_category() is removed. Please use coursecat::get(), see phpdocs for more details'); |
2d8a275b | 1480 | } |
9bad61db MG |
1481 | |
1482 | /** | |
9bad61db MG |
1483 | * This function is deprecated. It is replaced with the method create() in class coursecat. |
1484 | * {@link coursecat::create()} also verifies the data, fixes sortorder and logs the action | |
1485 | * | |
1486 | * @deprecated since 2.5 | |
9bad61db MG |
1487 | */ |
1488 | function create_course_category($category) { | |
2149326b | 1489 | throw new coding_exception('Function create_course_category() is removed. Please use coursecat::create(), see phpdocs for more details'); |
9bad61db | 1490 | } |
bc81b006 MG |
1491 | |
1492 | /** | |
bc81b006 MG |
1493 | * This function is deprecated. |
1494 | * | |
1495 | * To get visible children categories of the given category use: | |
1496 | * coursecat::get($categoryid)->get_children(); | |
1497 | * This function will return the array or coursecat objects, on each of them | |
1498 | * you can call get_children() again | |
1499 | * | |
1500 | * @see coursecat::get() | |
1501 | * @see coursecat::get_children() | |
1502 | * | |
1503 | * @deprecated since 2.5 | |
bc81b006 MG |
1504 | */ |
1505 | function get_all_subcategories($catid) { | |
2149326b | 1506 | throw new coding_exception('Function get_all_subcategories() is removed. Please use appropriate methods() of coursecat |
1ac1d29b | 1507 | class. See phpdocs for more details'); |
bc81b006 | 1508 | } |
8db5dcb7 MG |
1509 | |
1510 | /** | |
8db5dcb7 MG |
1511 | * This function is deprecated. Please use functions in class coursecat: |
1512 | * - coursecat::get($parentid)->has_children() | |
1513 | * tells if the category has children (visible or not to the current user) | |
1514 | * | |
1515 | * - coursecat::get($parentid)->get_children() | |
1516 | * returns an array of coursecat objects, each of them represents a children category visible | |
1517 | * to the current user (i.e. visible=1 or user has capability to view hidden categories) | |
1518 | * | |
1519 | * - coursecat::get($parentid)->get_children_count() | |
1520 | * returns number of children categories visible to the current user | |
1521 | * | |
1522 | * - coursecat::count_all() | |
1523 | * returns total count of all categories in the system (both visible and not) | |
1524 | * | |
1525 | * - coursecat::get_default() | |
1526 | * returns the first category (usually to be used if count_all() == 1) | |
1527 | * | |
1528 | * @deprecated since 2.5 | |
8db5dcb7 MG |
1529 | */ |
1530 | function get_child_categories($parentid) { | |
2149326b | 1531 | throw new coding_exception('Function get_child_categories() is removed. Use coursecat::get_children() or see phpdocs for |
1ac1d29b | 1532 | more details.'); |
8db5dcb7 | 1533 | } |
e1d54562 MG |
1534 | |
1535 | /** | |
e1d54562 MG |
1536 | * |
1537 | * @deprecated since 2.5 | |
1538 | * | |
1539 | * This function is deprecated. Use appropriate functions from class coursecat. | |
1540 | * Examples: | |
1541 | * | |
1542 | * coursecat::get($categoryid)->get_children() | |
1543 | * - returns all children of the specified category as instances of class | |
0198b4a5 MG |
1544 | * coursecat, which means on each of them method get_children() can be called again. |
1545 | * Only categories visible to the current user are returned. | |
e1d54562 | 1546 | * |
0198b4a5 MG |
1547 | * coursecat::get(0)->get_children() |
1548 | * - returns all top-level categories visible to the current user. | |
e1d54562 MG |
1549 | * |
1550 | * Sort fields can be specified, see phpdocs to {@link coursecat::get_children()} | |
1551 | * | |
0198b4a5 MG |
1552 | * coursecat::make_categories_list() |
1553 | * - returns an array of all categories id/names in the system. | |
1554 | * Also only returns categories visible to current user and can additionally be | |
1555 | * filetered by capability, see phpdocs to {@link coursecat::make_categories_list()} | |
1556 | * | |
1557 | * make_categories_options() | |
1558 | * - Returns full course categories tree to be used in html_writer::select() | |
1559 | * | |
e1d54562 MG |
1560 | * Also see functions {@link coursecat::get_children_count()}, {@link coursecat::count_all()}, |
1561 | * {@link coursecat::get_default()} | |
e1d54562 MG |
1562 | */ |
1563 | function get_categories($parent='none', $sort=NULL, $shallow=true) { | |
2149326b | 1564 | throw new coding_exception('Function get_categories() is removed. Please use coursecat::get_children() or see phpdocs for other alternatives'); |
e1d54562 | 1565 | } |
a8d683ca MG |
1566 | |
1567 | /** | |
a8d683ca MG |
1568 | * This function is deprecated, please use course renderer: |
1569 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1570 | * echo $renderer->course_search_form($value, $format); | |
1571 | * | |
1572 | * @deprecated since 2.5 | |
a8d683ca MG |
1573 | */ |
1574 | function print_course_search($value="", $return=false, $format="plain") { | |
2149326b | 1575 | throw new coding_exception('Function print_course_search() is removed, please use course renderer'); |
a8d683ca | 1576 | } |
09ae7ee0 MG |
1577 | |
1578 | /** | |
09ae7ee0 MG |
1579 | * This function is deprecated, please use: |
1580 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1581 | * echo $renderer->frontpage_my_courses() | |
1582 | * | |
1583 | * @deprecated since 2.5 | |
1584 | */ | |
1585 | function print_my_moodle() { | |
2149326b | 1586 | throw new coding_exception('Function print_my_moodle() is removed, please use course renderer function frontpage_my_courses()'); |
09ae7ee0 MG |
1587 | } |
1588 | ||
1589 | /** | |
09ae7ee0 MG |
1590 | * This function is deprecated, it is replaced with protected function |
1591 | * {@link core_course_renderer::frontpage_remote_course()} | |
1592 | * It is only used from function {@link core_course_renderer::frontpage_my_courses()} | |
1593 | * | |
1594 | * @deprecated since 2.5 | |
1595 | */ | |
1596 | function print_remote_course($course, $width="100%") { | |
2149326b | 1597 | throw new coding_exception('Function print_remote_course() is removed, please use course renderer'); |
09ae7ee0 MG |
1598 | } |
1599 | ||
1600 | /** | |
09ae7ee0 MG |
1601 | * This function is deprecated, it is replaced with protected function |
1602 | * {@link core_course_renderer::frontpage_remote_host()} | |
1603 | * It is only used from function {@link core_course_renderer::frontpage_my_courses()} | |
1604 | * | |
1605 | * @deprecated since 2.5 | |
1606 | */ | |
1607 | function print_remote_host($host, $width="100%") { | |
2149326b | 1608 | throw new coding_exception('Function print_remote_host() is removed, please use course renderer'); |
09ae7ee0 MG |
1609 | } |
1610 | ||
1611 | /** | |
09ae7ee0 MG |
1612 | * @deprecated since 2.5 |
1613 | * | |
1614 | * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5 | |
1615 | */ | |
1616 | function print_whole_category_list($category=NULL, $displaylist=NULL, $parentslist=NULL, $depth=-1, $showcourses = true, $categorycourses=NULL) { | |
2149326b | 1617 | throw new coding_exception('Function print_whole_category_list() is removed, please use course renderer'); |
09ae7ee0 MG |
1618 | } |
1619 | ||
1620 | /** | |
09ae7ee0 | 1621 | * @deprecated since 2.5 |
09ae7ee0 MG |
1622 | */ |
1623 | function print_category_info($category, $depth = 0, $showcourses = false, array $courses = null) { | |
2149326b | 1624 | throw new coding_exception('Function print_category_info() is removed, please use course renderer'); |
09ae7ee0 MG |
1625 | } |
1626 | ||
1627 | /** | |
09ae7ee0 MG |
1628 | * @deprecated since 2.5 |
1629 | * | |
1630 | * This function is not used any more in moodle core and course renderer does not have render function for it. | |
1631 | * Combo list on the front page is displayed as: | |
1632 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1633 | * echo $renderer->frontpage_combo_list() | |
1634 | * | |
1635 | * The new class {@link coursecat} stores the information about course category tree | |
1636 | * To get children categories use: | |
1637 | * coursecat::get($id)->get_children() | |
1638 | * To get list of courses use: | |
1639 | * coursecat::get($id)->get_courses() | |
1640 | * | |
1641 | * See http://docs.moodle.org/dev/Courses_lists_upgrade_to_2.5 | |
09ae7ee0 MG |
1642 | */ |
1643 | function get_course_category_tree($id = 0, $depth = 0) { | |
2149326b | 1644 | throw new coding_exception('Function get_course_category_tree() is removed, please use course renderer or coursecat class, |
1ac1d29b | 1645 | see function phpdocs for more info'); |
09ae7ee0 MG |
1646 | } |
1647 | ||
1648 | /** | |
09ae7ee0 MG |
1649 | * @deprecated since 2.5 |
1650 | * | |
1651 | * To print a generic list of courses use: | |
1652 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1653 | * echo $renderer->courses_list($courses); | |
1654 | * | |
1655 | * To print list of all courses: | |
1656 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1657 | * echo $renderer->frontpage_available_courses(); | |
1658 | * | |
1659 | * To print list of courses inside category: | |
1660 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1661 | * echo $renderer->course_category($category); // this will also print subcategories | |
09ae7ee0 MG |
1662 | */ |
1663 | function print_courses($category) { | |
2149326b | 1664 | throw new coding_exception('Function print_courses() is removed, please use course renderer'); |
09ae7ee0 MG |
1665 | } |
1666 | ||
1667 | /** | |
09ae7ee0 MG |
1668 | * @deprecated since 2.5 |
1669 | * | |
1670 | * Please use course renderer to display a course information box. | |
1671 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1672 | * echo $renderer->courses_list($courses); // will print list of courses | |
1673 | * echo $renderer->course_info_box($course); // will print one course wrapped in div.generalbox | |
09ae7ee0 MG |
1674 | */ |
1675 | function print_course($course, $highlightterms = '') { | |
2149326b | 1676 | throw new coding_exception('Function print_course() is removed, please use course renderer'); |
09ae7ee0 MG |
1677 | } |
1678 | ||
1679 | /** | |
09ae7ee0 MG |
1680 | * @deprecated since 2.5 |
1681 | * | |
1682 | * This function is not used any more in moodle core and course renderer does not have render function for it. | |
1683 | * Combo list on the front page is displayed as: | |
1684 | * $renderer = $PAGE->get_renderer('core', 'course'); | |
1685 | * echo $renderer->frontpage_combo_list() | |
1686 | * | |
1687 | * The new class {@link coursecat} stores the information about course category tree | |
1688 | * To get children categories use: | |
1689 | * coursecat::get($id)->get_children() | |
1690 | * To get list of courses use: | |
1691 | * coursecat::get($id)->get_courses() | |
09ae7ee0 MG |
1692 | */ |
1693 | function get_category_courses_array($categoryid = 0) { | |
2149326b | 1694 | throw new coding_exception('Function get_category_courses_array() is removed, please use methods of coursecat class'); |
09ae7ee0 MG |
1695 | } |
1696 | ||
1697 | /** | |
09ae7ee0 | 1698 | * @deprecated since 2.5 |
09ae7ee0 MG |
1699 | */ |
1700 | function get_category_courses_array_recursively(array &$flattened, $category) { | |
2149326b | 1701 | throw new coding_exception('Function get_category_courses_array_recursively() is removed, please use methods of coursecat class', DEBUG_DEVELOPER); |
09ae7ee0 MG |
1702 | } |
1703 | ||
7ac18cf9 | 1704 | /** |
7ac18cf9 | 1705 | * @deprecated since Moodle 2.5 MDL-27814 - please do not use this function any more. |
7ac18cf9 AA |
1706 | */ |
1707 | function blog_get_context_url($context=null) { | |
2149326b | 1708 | throw new coding_exception('Function blog_get_context_url() is removed, getting params from context is not reliable for blogs.'); |
7ac18cf9 AA |
1709 | } |
1710 | ||
09ae7ee0 | 1711 | /** |
09ae7ee0 MG |
1712 | * @deprecated since 2.5 |
1713 | * | |
1714 | * To get list of all courses with course contacts ('managers') use | |
1715 | * coursecat::get(0)->get_courses(array('recursive' => true, 'coursecontacts' => true)); | |
1716 | * | |
1717 | * To get list of courses inside particular category use | |
1718 | * coursecat::get($id)->get_courses(array('coursecontacts' => true)); | |
1719 | * | |
1720 | * Additionally you can specify sort order, offset and maximum number of courses, | |
1721 | * see {@link coursecat::get_courses()} | |
09ae7ee0 MG |
1722 | */ |
1723 | function get_courses_wmanagers($categoryid=0, $sort="c.sortorder ASC", $fields=array()) { | |
2149326b | 1724 | throw new coding_exception('Function get_courses_wmanagers() is removed, please use coursecat::get_courses()'); |
09ae7ee0 | 1725 | } |
c269b9d1 MG |
1726 | |
1727 | /** | |
c269b9d1 | 1728 | * @deprecated since 2.5 |
c269b9d1 MG |
1729 | */ |
1730 | function convert_tree_to_html($tree, $row=0) { | |
2149326b | 1731 | throw new coding_exception('Function convert_tree_to_html() is removed. Consider using class tabtree and core_renderer::render_tabtree()'); |
c269b9d1 MG |
1732 | } |
1733 | ||
1734 | /** | |
c269b9d1 | 1735 | * @deprecated since 2.5 |
c269b9d1 MG |
1736 | */ |
1737 | function convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated) { | |
2149326b | 1738 | throw new coding_exception('Function convert_tabrows_to_tree() is removed. Consider using class tabtree'); |
c269b9d1 | 1739 | } |
9052fc44 | 1740 | |
8ef3a222 | 1741 | /** |
8ef3a222 | 1742 | * @deprecated since 2.5 - do not use, the textrotate.js will work it out automatically |
8ef3a222 DP |
1743 | */ |
1744 | function can_use_rotated_text() { | |
2149326b | 1745 | debugging('can_use_rotated_text() is removed. JS feature detection is used automatically.'); |
8ef3a222 | 1746 | } |
61a0299a | 1747 | |
ce2b2150 | 1748 | /** |
ce2b2150 | 1749 | * @deprecated since Moodle 2.2 MDL-35009 - please do not use this function any more. |
ce2b2150 | 1750 | * @see context::instance_by_id($id) |
ce2b2150 RT |
1751 | */ |
1752 | function get_context_instance_by_id($id, $strictness = IGNORE_MISSING) { | |
f9b7be4f | 1753 | throw new coding_exception('get_context_instance_by_id() is now removed, please use context::instance_by_id($id) instead.'); |
ce2b2150 | 1754 | } |
85b2e46f | 1755 | |
492ba9de AA |
1756 | /** |
1757 | * Returns system context or null if can not be created yet. | |
1758 | * | |
1759 | * @see context_system::instance() | |
01546175 | 1760 | * @deprecated since 2.2 |
492ba9de AA |
1761 | * @param bool $cache use caching |
1762 | * @return context system context (null if context table not created yet) | |
1763 | */ | |
1764 | function get_system_context($cache = true) { | |
1765 | debugging('get_system_context() is deprecated, please use context_system::instance() instead.', DEBUG_DEVELOPER); | |
1766 | return context_system::instance(0, IGNORE_MISSING, $cache); | |
1767 | } | |
8e8891b7 FM |
1768 | |
1769 | /** | |
8e8891b7 FM |
1770 | * @see context::get_parent_context_ids() |
1771 | * @deprecated since 2.2, use $context->get_parent_context_ids() instead | |
8e8891b7 FM |
1772 | */ |
1773 | function get_parent_contexts(context $context, $includeself = false) { | |
2149326b | 1774 | throw new coding_exception('get_parent_contexts() is removed, please use $context->get_parent_context_ids() instead.'); |
8e8891b7 | 1775 | } |
766fd0d9 AD |
1776 | |
1777 | /** | |
7f5b51c4 RT |
1778 | * @deprecated since Moodle 2.2 |
1779 | * @see context::get_parent_context() | |
766fd0d9 | 1780 | */ |
7f5b51c4 | 1781 | function get_parent_contextid(context $context) { |
2149326b | 1782 | throw new coding_exception('get_parent_contextid() is removed, please use $context->get_parent_context() instead.'); |
766fd0d9 | 1783 | } |
f9aa8016 FM |
1784 | |
1785 | /** | |
f9aa8016 FM |
1786 | * @see context::get_child_contexts() |
1787 | * @deprecated since 2.2 | |
f9aa8016 FM |
1788 | */ |
1789 | function get_child_contexts(context $context) { | |
2149326b | 1790 | throw new coding_exception('get_child_contexts() is removed, please use $context->get_child_contexts() instead.'); |
f9aa8016 | 1791 | } |
9fdbf620 FM |
1792 | |
1793 | /** | |
9fdbf620 FM |
1794 | * @see context_helper::create_instances() |
1795 | * @deprecated since 2.2 | |
9fdbf620 FM |
1796 | */ |
1797 | function create_contexts($contextlevel = null, $buildpaths = true) { | |
2149326b | 1798 | throw new coding_exception('create_contexts() is removed, please use context_helper::create_instances() instead.'); |
9fdbf620 | 1799 | } |
84378a57 FM |
1800 | |
1801 | /** | |
84378a57 FM |
1802 | * @see context_helper::cleanup_instances() |
1803 | * @deprecated since 2.2 | |
84378a57 FM |
1804 | */ |
1805 | function cleanup_contexts() { | |
2149326b | 1806 | throw new coding_exception('cleanup_contexts() is removed, please use context_helper::cleanup_instances() instead.'); |
84378a57 | 1807 | } |
79f6b384 FM |
1808 | |
1809 | /** | |
1810 | * Populate context.path and context.depth where missing. | |
1811 | * | |
79f6b384 | 1812 | * @deprecated since 2.2 |
79f6b384 FM |
1813 | */ |
1814 | function build_context_path($force = false) { | |
2149326b | 1815 | throw new coding_exception('build_context_path() is removed, please use context_helper::build_all_paths() instead.'); |
79f6b384 | 1816 | } |
cc4de415 FM |
1817 | |
1818 | /** | |
cc4de415 | 1819 | * @deprecated since 2.2 |
cc4de415 FM |
1820 | */ |
1821 | function rebuild_contexts(array $fixcontexts) { | |
2149326b | 1822 | throw new coding_exception('rebuild_contexts() is removed, please use $context->reset_paths(true) instead.'); |
cc4de415 | 1823 | } |
8f7d3d12 RT |
1824 | |
1825 | /** | |
8f7d3d12 RT |
1826 | * @deprecated since Moodle 2.2 |
1827 | * @see context_helper::preload_course() | |
8f7d3d12 RT |
1828 | */ |
1829 | function preload_course_contexts($courseid) { | |
2149326b | 1830 | throw new coding_exception('preload_course_contexts() is removed, please use context_helper::preload_course() instead.'); |
8f7d3d12 | 1831 | } |
2c5b0eb7 RT |
1832 | |
1833 | /** | |
2c5b0eb7 RT |
1834 | * @deprecated since Moodle 2.2 |
1835 | * @see context::update_moved() | |
2c5b0eb7 RT |
1836 | */ |
1837 | function context_moved(context $context, context $newparent) { | |
2149326b | 1838 | throw new coding_exception('context_moved() is removed, please use context::update_moved() instead.'); |
c5dcd25d AA |
1839 | } |
1840 | ||
a439b2f9 | 1841 | /** |
a439b2f9 FM |
1842 | * @see context::get_capabilities() |
1843 | * @deprecated since 2.2 | |
a439b2f9 FM |
1844 | */ |
1845 | function fetch_context_capabilities(context $context) { | |
2149326b | 1846 | throw new coding_exception('fetch_context_capabilities() is removed, please use $context->get_capabilities() instead.'); |
a439b2f9 FM |
1847 | } |
1848 | ||
c5dcd25d | 1849 | /** |
c5dcd25d AA |
1850 | * @deprecated since 2.2 |
1851 | * @see context_helper::preload_from_record() | |
c5dcd25d AA |
1852 | */ |
1853 | function context_instance_preload(stdClass $rec) { | |
2149326b | 1854 | throw new coding_exception('context_instance_preload() is removed, please use context_helper::preload_from_record() instead.'); |
c5dcd25d | 1855 | } |
b4482dfe AG |
1856 | |
1857 | /** | |
1858 | * Returns context level name | |
1859 | * | |
1860 | * @deprecated since 2.2 | |
1861 | * @see context_helper::get_level_name() | |
b4482dfe AG |
1862 | */ |
1863 | function get_contextlevel_name($contextlevel) { | |
2149326b | 1864 | throw new coding_exception('get_contextlevel_name() is removed, please use context_helper::get_level_name() instead.'); |
b4482dfe | 1865 | } |
329846f1 AG |
1866 | |
1867 | /** | |
329846f1 AG |
1868 | * @deprecated since 2.2 |
1869 | * @see context::get_context_name() | |
329846f1 AG |
1870 | */ |
1871 | function print_context_name(context $context, $withprefix = true, $short = false) { | |
2149326b | 1872 | throw new coding_exception('print_context_name() is removed, please use $context->get_context_name() instead.'); |
329846f1 | 1873 | } |
1de02d62 AG |
1874 | |
1875 | /** | |
1de02d62 AG |
1876 | * @deprecated since 2.2, use $context->mark_dirty() instead |
1877 | * @see context::mark_dirty() | |
1de02d62 AG |
1878 | */ |
1879 | function mark_context_dirty($path) { | |
2149326b | 1880 | throw new coding_exception('mark_context_dirty() is removed, please use $context->mark_dirty() instead.'); |
1de02d62 | 1881 | } |
c592eea2 RT |
1882 | |
1883 | /** | |
c592eea2 RT |
1884 | * @deprecated since Moodle 2.2 |
1885 | * @see context_helper::delete_instance() or context::delete_content() | |
c592eea2 RT |
1886 | */ |
1887 | function delete_context($contextlevel, $instanceid, $deleterecord = true) { | |
1888 | if ($deleterecord) { | |
2149326b | 1889 | throw new coding_exception('delete_context() is removed, please use context_helper::delete_instance() instead.'); |
c592eea2 | 1890 | } else { |
2149326b | 1891 | throw new coding_exception('delete_context() is removed, please use $context->delete_content() instead.'); |
c592eea2 | 1892 | } |
c592eea2 | 1893 | } |
6c89d4e1 MN |
1894 | |
1895 | /** | |
6c89d4e1 MN |
1896 | * @deprecated since 2.2 |
1897 | * @see context::get_url() | |
6c89d4e1 MN |
1898 | */ |
1899 | function get_context_url(context $context) { | |
2149326b | 1900 | throw new coding_exception('get_context_url() is removed, please use $context->get_url() instead.'); |
6c89d4e1 MN |
1901 | } |
1902 | ||
dd33f4af | 1903 | /** |
dd33f4af MN |
1904 | * @deprecated since 2.2 |
1905 | * @see context::get_course_context() | |
dd33f4af MN |
1906 | */ |
1907 | function get_course_context(context $context) { | |
2149326b | 1908 | throw new coding_exception('get_course_context() is removed, please use $context->get_course_context(true) instead.'); |
dd33f4af | 1909 | } |
6acc54b3 AA |
1910 | |
1911 | /** | |
6acc54b3 AA |
1912 | * @deprecated since 2.2 |
1913 | * @see enrol_get_users_courses() | |
6acc54b3 AA |
1914 | */ |
1915 | function get_user_courses_bycap($userid, $cap, $accessdata_ignored, $doanything_ignored, $sort = 'c.sortorder ASC', $fields = null, $limit_ignored = 0) { | |
1916 | ||
2149326b | 1917 | throw new coding_exception('get_user_courses_bycap() is removed, please use enrol_get_users_courses() instead.'); |
6acc54b3 | 1918 | } |
ae38dcb1 RT |
1919 | |
1920 | /** | |
ae38dcb1 | 1921 | * @deprecated since Moodle 2.2 |
ae38dcb1 RT |
1922 | */ |
1923 | function get_role_context_caps($roleid, context $context) { | |
2149326b | 1924 | throw new coding_exception('get_role_context_caps() is removed, it is really slow. Don\'t use it.'); |
ae38dcb1 | 1925 | } |
b123a543 FM |
1926 | |
1927 | /** | |
b123a543 FM |
1928 | * @see context::get_course_context() |
1929 | * @deprecated since 2.2 | |
b123a543 FM |
1930 | */ |
1931 | function get_courseid_from_context(context $context) { | |
2149326b | 1932 | throw new coding_exception('get_courseid_from_context() is removed, please use $context->get_course_context(false) instead.'); |
6a30b48d | 1933 | } |
2e4c0c91 FM |
1934 | |
1935 | /** | |
2e4c0c91 FM |
1936 | * If you are using this methid, you should have something like this: |
1937 | * | |
1938 | * list($ctxselect, $ctxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx'); | |
1939 | * | |
1940 | * To prevent the use of this deprecated function, replace the line above with something similar to this: | |
1941 | * | |
1942 | * $ctxselect = ', ' . context_helper::get_preload_record_columns_sql('ctx'); | |
1943 | * ^ | |
1944 | * $ctxjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)"; | |
1945 | * ^ ^ ^ ^ | |
1946 | * $params = array('contextlevel' => CONTEXT_COURSE); | |
1947 | * ^ | |
1948 | * @see context_helper:;get_preload_record_columns_sql() | |
1949 | * @deprecated since 2.2 | |
2e4c0c91 FM |
1950 | */ |
1951 | function context_instance_preload_sql($joinon, $contextlevel, $tablealias) { | |
2149326b | 1952 | throw new coding_exception('context_instance_preload_sql() is removed, please use context_helper::get_preload_record_columns_sql() instead.'); |
b123a543 | 1953 | } |
b6452844 MN |
1954 | |
1955 | /** | |
b6452844 MN |
1956 | * @deprecated since 2.2 |
1957 | * @see context::get_parent_context_ids() | |
b6452844 MN |
1958 | */ |
1959 | function get_related_contexts_string(context $context) { | |
2149326b | 1960 | throw new coding_exception('get_related_contexts_string() is removed, please use $context->get_parent_context_ids(true) instead.'); |
b6452844 | 1961 | } |
0142523d | 1962 | |
d0cac8b5 | 1963 | /** |
d0cac8b5 FM |
1964 | * @deprecated since 2.6 |
1965 | * @see core_component::get_plugin_list_with_file() | |
1966 | */ | |
1967 | function get_plugin_list_with_file($plugintype, $file, $include = false) { | |
2149326b | 1968 | throw new coding_exception('get_plugin_list_with_file() is removed, please use core_component::get_plugin_list_with_file() instead.'); |
d0cac8b5 | 1969 | } |
c3d2fbf9 SH |
1970 | |
1971 | /** | |
c3d2fbf9 | 1972 | * @deprecated since 2.6 |
c3d2fbf9 SH |
1973 | */ |
1974 | function check_browser_operating_system($brand) { | |
2149326b | 1975 | throw new coding_exception('check_browser_operating_system is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
1976 | } |
1977 | ||
1978 | /** | |
c3d2fbf9 | 1979 | * @deprecated since 2.6 |
c3d2fbf9 SH |
1980 | */ |
1981 | function check_browser_version($brand, $version = null) { | |
2149326b | 1982 | throw new coding_exception('check_browser_version is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
1983 | } |
1984 | ||
1985 | /** | |
c3d2fbf9 | 1986 | * @deprecated since 2.6 |
c3d2fbf9 SH |
1987 | */ |
1988 | function get_device_type() { | |
2149326b | 1989 | throw new coding_exception('get_device_type is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
1990 | } |
1991 | ||
1992 | /** | |
c3d2fbf9 | 1993 | * @deprecated since 2.6 |
c3d2fbf9 SH |
1994 | */ |
1995 | function get_device_type_list($incusertypes = true) { | |
2149326b | 1996 | throw new coding_exception('get_device_type_list is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
1997 | } |
1998 | ||
1999 | /** | |
c3d2fbf9 | 2000 | * @deprecated since 2.6 |
c3d2fbf9 SH |
2001 | */ |
2002 | function get_selected_theme_for_device_type($devicetype = null) { | |
2149326b | 2003 | throw new coding_exception('get_selected_theme_for_device_type is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
2004 | } |
2005 | ||
2006 | /** | |
c3d2fbf9 | 2007 | * @deprecated since 2.6 |
c3d2fbf9 SH |
2008 | */ |
2009 | function get_device_cfg_var_name($devicetype = null) { | |
2149326b | 2010 | throw new coding_exception('get_device_cfg_var_name is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
2011 | } |
2012 | ||
2013 | /** | |
c3d2fbf9 | 2014 | * @deprecated since 2.6 |
c3d2fbf9 SH |
2015 | */ |
2016 | function set_user_device_type($newdevice) { | |
2149326b | 2017 | throw new coding_exception('set_user_device_type is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
2018 | } |
2019 | ||
2020 | /** | |
c3d2fbf9 | 2021 | * @deprecated since 2.6 |
c3d2fbf9 SH |
2022 | */ |
2023 | function get_user_device_type() { | |
2149326b | 2024 | throw new coding_exception('get_user_device_type is removed, please update your code to use core_useragent instead.'); |
c3d2fbf9 SH |
2025 | } |
2026 | ||
2027 | /** | |
c3d2fbf9 | 2028 | * @deprecated since 2.6 |
c3d2fbf9 SH |
2029 | */ |
2030 | function get_browser_version_classes() { | |
2149326b | 2031 | throw new coding_exception('get_browser_version_classes is removed, please update your code to use core_useragent instead.'); |
2b503e40 RT |
2032 | } |
2033 | ||
2034 | /** | |
2b503e40 RT |
2035 | * @deprecated since Moodle 2.6 |
2036 | * @see core_user::get_support_user() | |
2b503e40 RT |
2037 | */ |
2038 | function generate_email_supportuser() { | |
2149326b | 2039 | throw new coding_exception('generate_email_supportuser is removed, please use core_user::get_support_user'); |
853e506a Y |
2040 | } |
2041 | ||
2042 | /** | |
853e506a | 2043 | * @deprecated since Moodle 2.6 |
853e506a Y |
2044 | */ |
2045 | function badges_get_issued_badge_info($hash) { | |
2149326b | 2046 | throw new coding_exception('Function badges_get_issued_badge_info() is removed. Please use core_badges_assertion class and methods to generate badge assertion.'); |
853e506a | 2047 | } |
3d27180e DW |
2048 | |
2049 | /** | |
3d27180e | 2050 | * @deprecated since 2.6 |
3d27180e DW |
2051 | */ |
2052 | function can_use_html_editor() { | |
2149326b | 2053 | throw new coding_exception('can_use_html_editor is removed, please update your code to assume it returns true.'); |
3d27180e | 2054 | } |
52dc1de7 AA |
2055 | |
2056 | ||
2057 | /** | |
26e4b0ca | 2058 | * @deprecated since Moodle 2.7, use {@link user_count_login_failures()} instead. |
52dc1de7 AA |
2059 | */ |
2060 | function count_login_failures($mode, $username, $lastlogin) { | |
26e4b0ca | 2061 | throw new coding_exception('count_login_failures() can not be used any more, please use user_count_login_failures().'); |
52dc1de7 | 2062 | } |
de878a38 | 2063 | |
6538153b | 2064 | /** |
44ab05b3 | 2065 | * @deprecated since 2.7 MDL-33099/MDL-44088 - please do not use this function any more. |
6538153b FM |
2066 | */ |
2067 | function ajaxenabled(array $browsers = null) { | |
44ab05b3 | 2068 | throw new coding_exception('ajaxenabled() can not be used anymore. Update your code to work with JS at all times.'); |
6538153b | 2069 | } |
8d1f33e1 | 2070 | |
2071 | /** | |
e56e8e3a | 2072 | * @deprecated Since Moodle 2.7 MDL-44070 |
8d1f33e1 | 2073 | */ |
2074 | function coursemodule_visible_for_user($cm, $userid=0) { | |
e56e8e3a AA |
2075 | throw new coding_exception('coursemodule_visible_for_user() can not be used any more, |
2076 | please use \core_availability\info_module::is_user_visible()'); | |
8d1f33e1 | 2077 | } |
80f98467 MG |
2078 | |
2079 | /** | |
58b5b04d | 2080 | * @deprecated since Moodle 2.8 MDL-36014, MDL-35618 this functionality is removed |
80f98467 MG |
2081 | */ |
2082 | function enrol_cohort_get_cohorts(course_enrolment_manager $manager) { | |
2149326b | 2083 | throw new coding_exception('Function enrol_cohort_get_cohorts() is removed, use enrol_cohort_search_cohorts() or '. |
1ac1d29b | 2084 | 'cohort_get_available_cohorts() instead'); |
80f98467 MG |
2085 | } |
2086 | ||
2087 | /** | |
80f98467 MG |
2088 | * This function is deprecated, use {@link cohort_can_view_cohort()} instead since it also |
2089 | * takes into account current context | |
2090 | * | |
2091 | * @deprecated since Moodle 2.8 MDL-36014 please use cohort_can_view_cohort() | |
80f98467 MG |
2092 | */ |
2093 | function enrol_cohort_can_view_cohort($cohortid) { | |
2149326b | 2094 | throw new coding_exception('Function enrol_cohort_can_view_cohort() is removed, use cohort_can_view_cohort() instead'); |
80f98467 MG |
2095 | } |
2096 | ||
2097 | /** | |
80f98467 MG |
2098 | * It is advisable to use {@link cohort_get_available_cohorts()} instead. |
2099 | * | |
2100 | * @deprecated since Moodle 2.8 MDL-36014 use cohort_get_available_cohorts() instead | |
80f98467 MG |
2101 | */ |
2102 | function cohort_get_visible_list($course, $onlyenrolled=true) { | |
2149326b | 2103 | throw new coding_exception('Function cohort_get_visible_list() is removed. Please use function cohort_get_available_cohorts() ". |
1ac1d29b | 2104 | "that correctly checks capabilities.'); |
80f98467 | 2105 | } |
58b5b04d MG |
2106 | |
2107 | /** | |
58b5b04d | 2108 | * @deprecated since Moodle 2.8 MDL-35618 this functionality is removed |
58b5b04d MG |
2109 | */ |
2110 | function enrol_cohort_enrol_all_users(course_enrolment_manager $manager, $cohortid, $roleid) { | |
2149326b | 2111 | throw new coding_exception('enrol_cohort_enrol_all_users() is removed. This functionality is moved to enrol_manual.'); |
58b5b04d MG |
2112 | } |
2113 | ||
2114 | /** | |
58b5b04d | 2115 | * @deprecated since Moodle 2.8 MDL-35618 this functionality is removed |
58b5b04d MG |
2116 | */ |
2117 | function enrol_cohort_search_cohorts(course_enrolment_manager $manager, $offset = 0, $limit = 25, $search = '') { | |
2149326b | 2118 | throw new coding_exception('enrol_cohort_search_cohorts() is removed. This functionality is moved to enrol_manual.'); |
58b5b04d | 2119 | } |
bdc83277 | 2120 | |
8322ed4a AA |
2121 | /* === Apis deprecated in since Moodle 2.9 === */ |
2122 | ||
bdc83277 DM |
2123 | /** |
2124 | * Is $USER one of the supplied users? | |
2125 | * | |
2126 | * $user2 will be null if viewing a user's recent conversations | |
2127 | * | |
2128 | * @deprecated since Moodle 2.9 MDL-49371 - please do not use this function any more. | |
bdc83277 DM |
2129 | */ |
2130 | function message_current_user_is_involved($user1, $user2) { | |
be43ad0d | 2131 | throw new coding_exception('message_current_user_is_involved() can not be used any more.'); |
bdc83277 | 2132 | } |
b19cc4ef AA |
2133 | |
2134 | /** | |
2135 | * Print badges on user profile page. | |
2136 | * | |
2137 | * @deprecated since Moodle 2.9 MDL-45898 - please do not use this function any more. | |
b19cc4ef AA |
2138 | */ |
2139 | function profile_display_badges($userid, $courseid = 0) { | |
a77e0611 | 2140 | throw new coding_exception('profile_display_badges() can not be used any more.'); |
b19cc4ef | 2141 | } |
efd32edb AG |
2142 | |
2143 | /** | |
2144 | * Adds user preferences elements to user edit form. | |
2145 | * | |
2146 | * @deprecated since Moodle 2.9 MDL-45774 - Please do not use this function any more. | |
efd32edb AG |
2147 | */ |
2148 | function useredit_shared_definition_preferences($user, &$mform, $editoroptions = null, $filemanageroptions = null) { | |
ab2d9b34 | 2149 | throw new coding_exception('useredit_shared_definition_preferences() can not be used any more.'); |
efd32edb | 2150 | } |
8322ed4a AA |
2151 | |
2152 | ||
2153 | /** | |
2154 | * Convert region timezone to php supported timezone | |
2155 | * | |
2156 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2157 | */ |
2158 | function calendar_normalize_tz($tz) { | |
678b315f | 2159 | throw new coding_exception('calendar_normalize_tz() can not be used any more, please use core_date::normalise_timezone() instead.'); |
8322ed4a AA |
2160 | } |
2161 | ||
2162 | /** | |
2163 | * Returns a float which represents the user's timezone difference from GMT in hours | |
2164 | * Checks various settings and picks the most dominant of those which have a value | |
2165 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2166 | */ |
2167 | function get_user_timezone_offset($tz = 99) { | |
a77e0611 SL |
2168 | throw new coding_exception('get_user_timezone_offset() can not be used any more, please use standard PHP DateTimeZone class instead'); |
2169 | ||
8322ed4a AA |
2170 | } |
2171 | ||
2172 | /** | |
2173 | * Returns an int which represents the systems's timezone difference from GMT in seconds | |
2174 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2175 | */ |
2176 | function get_timezone_offset($tz) { | |
a77e0611 | 2177 | throw new coding_exception('get_timezone_offset() can not be used any more, please use standard PHP DateTimeZone class instead'); |
8322ed4a AA |
2178 | } |
2179 | ||
2180 | /** | |
2181 | * Returns a list of timezones in the current language. | |
2182 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2183 | */ |
2184 | function get_list_of_timezones() { | |
a77e0611 | 2185 | throw new coding_exception('get_list_of_timezones() can not be used any more, please use core_date::get_list_of_timezones() instead'); |
8322ed4a AA |
2186 | } |
2187 | ||
2188 | /** | |
2189 | * Previous internal API, it was not supposed to be used anywhere. | |
2190 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2191 | */ |
2192 | function update_timezone_records($timezones) { | |
a77e0611 | 2193 | throw new coding_exception('update_timezone_records() can not be used any more, please use standard PHP DateTime class instead'); |
8322ed4a AA |
2194 | } |
2195 | ||
2196 | /** | |
2197 | * Previous internal API, it was not supposed to be used anywhere. | |
2198 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2199 | */ |
2200 | function calculate_user_dst_table($fromyear = null, $toyear = null, $strtimezone = null) { | |
a77e0611 | 2201 | throw new coding_exception('calculate_user_dst_table() can not be used any more, please use standard PHP DateTime class instead'); |
8322ed4a AA |
2202 | } |
2203 | ||
2204 | /** | |
2205 | * Previous internal API, it was not supposed to be used anywhere. | |
2206 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2207 | */ |
2208 | function dst_changes_for_year($year, $timezone) { | |
a77e0611 | 2209 | throw new coding_exception('dst_changes_for_year() can not be used any more, please use standard DateTime class instead'); |
8322ed4a AA |
2210 | } |
2211 | ||
2212 | /** | |
2213 | * Previous internal API, it was not supposed to be used anywhere. | |
2214 | * @deprecated since Moodle 2.9 | |
8322ed4a AA |
2215 | */ |
2216 | function get_timezone_record($timezonename) { | |
a77e0611 | 2217 | throw new coding_exception('get_timezone_record() can not be used any more, please use standard PHP DateTime class instead'); |
8322ed4a AA |
2218 | } |
2219 | ||
2149326b | 2220 | /* === Apis deprecated since Moodle 3.0 === */ |
f4864c1c SL |
2221 | /** |
2222 | * Returns the URL of the HTTP_REFERER, less the querystring portion if required. | |
2223 | * | |
2224 | * @deprecated since Moodle 3.0 MDL-49360 - please do not use this function any more. | |
3046ee9f | 2225 | * @todo MDL-50265 Remove this function in Moodle 3.4. |
f4864c1c SL |
2226 | * @param boolean $stripquery if true, also removes the query part of the url. |
2227 | * @return string The resulting referer or empty string. | |
2228 | */ | |
2229 | function get_referer($stripquery = true) { | |
2230 | debugging('get_referer() is deprecated. Please use get_local_referer() instead.', DEBUG_DEVELOPER); | |
2231 | if (isset($_SERVER['HTTP_REFERER'])) { | |
2232 | if ($stripquery) { | |
2233 | return strip_querystring($_SERVER['HTTP_REFERER']); | |
2234 | } else { | |
2235 | return $_SERVER['HTTP_REFERER']; | |
2236 | } | |
2237 | } else { | |
2238 | return ''; | |
2239 | } | |
988592c5 | 2240 | } |
25d9ae9a | 2241 | |
34c6ec18 AN |
2242 | /** |
2243 | * Checks if current user is a web crawler. | |
2244 | * | |
2245 | * This list can not be made complete, this is not a security | |
2246 | * restriction, we make the list only to help these sites | |
2247 | * especially when automatic guest login is disabled. | |
2248 | * | |
2249 | * If admin needs security they should enable forcelogin | |
2250 | * and disable guest access!! | |
2251 | * | |
2252 | * @return bool | |
2253 | * @deprecated since Moodle 3.0 use \core_useragent::is_web_crawler instead. | |
2254 | */ | |
2255 | function is_web_crawler() { | |
182d9990 DM |
2256 | debugging('is_web_crawler() has been deprecated, please use core_useragent::is_web_crawler() instead.', DEBUG_DEVELOPER); |
2257 | return core_useragent::is_web_crawler(); | |
34c6ec18 | 2258 | } |
ebdfde76 | 2259 | |
0628925b DP |
2260 | /** |
2261 | * Update user's course completion statuses | |
2262 | * | |
2263 | * First update all criteria completions, then aggregate all criteria completions | |
2264 | * and update overall course completions. | |
2265 | * | |
2266 | * @deprecated since Moodle 3.0 MDL-50287 - please do not use this function any more. | |
2267 | * @todo Remove this function in Moodle 3.2 MDL-51226. | |
2268 | */ | |
2269 | function completion_cron() { | |
2270 | global $CFG; | |
2271 | require_once($CFG->dirroot.'/completion/cron.php'); | |
2272 | ||
2273 | debugging('completion_cron() is deprecated. Functionality has been moved to scheduled tasks.', DEBUG_DEVELOPER); | |
2274 | completion_cron_mark_started(); | |
2275 | ||
2276 | completion_cron_criteria(); | |
2277 | ||
2278 | completion_cron_completions(); | |
2279 | } | |
9e66dff0 | 2280 | |
0d1e5456 MG |
2281 | /** |
2282 | * Returns an ordered array of tags associated with visible courses | |
2283 | * (boosted replacement of get_all_tags() allowing association with user and tagtype). | |
2284 | * | |
2285 | * @deprecated since 3.0 | |
2286 | * @package core_tag | |
2287 | * @category tag | |
2288 | * @param int $courseid A course id. Passing 0 will return all distinct tags for all visible courses | |
2289 | * @param int $userid (optional) the user id, a default of 0 will return all users tags for the course | |
2290 | * @param string $tagtype (optional) The type of tag, empty string returns all types. Currently (Moodle 2.2) there are two | |
2291 | * types of tags which are used within Moodle, they are 'official' and 'default'. | |
2292 | * @param int $numtags (optional) number of tags to display, default of 80 is set in the block, 0 returns all | |
2293 | * @param string $unused (optional) was selected sorting, moved to tag_print_cloud() | |
2294 | * @return array | |
2295 | */ | |
2296 | function coursetag_get_tags($courseid, $userid=0, $tagtype='', $numtags=0, $unused = '') { | |
2297 | debugging('Function coursetag_get_tags() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2298 | ||
2299 | global $CFG, $DB; | |
2300 | ||
2301 | // get visible course ids | |
2302 | $courselist = array(); | |
2303 | if ($courseid === 0) { | |
2304 | if ($courses = $DB->get_records_select('course', 'visible=1 AND category>0', null, '', 'id')) { | |
2305 | foreach ($courses as $key => $value) { | |
2306 | $courselist[] = $key; | |
2307 | } | |
2308 | } | |
2309 | } | |
2310 | ||
2311 | // get tags from the db ordered by highest count first | |
2312 | $params = array(); | |
e11d7380 | 2313 | $sql = "SELECT id as tkey, name, id, isstandard, rawname, f.timemodified, flag, count |
0d1e5456 MG |
2314 | FROM {tag} t, |
2315 | (SELECT tagid, MAX(timemodified) as timemodified, COUNT(id) as count | |
2316 | FROM {tag_instance} | |
2317 | WHERE itemtype = 'course' "; | |
2318 | ||
2319 | if ($courseid > 0) { | |
2320 | $sql .= " AND itemid = :courseid "; | |
2321 | $params['courseid'] = $courseid; | |
2322 | } else { | |
2323 | if (!empty($courselist)) { | |
2324 | list($usql, $uparams) = $DB->get_in_or_equal($courselist, SQL_PARAMS_NAMED); | |
2325 | $sql .= "AND itemid $usql "; | |
2326 | $params = $params + $uparams; | |
2327 | } | |
2328 | } | |
2329 | ||
2330 | if ($userid > 0) { | |
2331 | $sql .= " AND tiuserid = :userid "; | |
2332 | $params['userid'] = $userid; | |
2333 | } | |
2334 | ||
2335 | $sql .= " GROUP BY tagid) f | |
2336 | WHERE t.id = f.tagid "; | |
2337 | if ($tagtype != '') { | |
e11d7380 MG |
2338 | $sql .= "AND isstandard = :isstandard "; |
2339 | $params['isstandard'] = ($tagtype === 'official') ? 1 : 0; | |
0d1e5456 MG |
2340 | } |
2341 | $sql .= "ORDER BY count DESC, name ASC"; | |
2342 | ||
2343 | // limit the number of tags for output | |
2344 | if ($numtags == 0) { | |
2345 | $tags = $DB->get_records_sql($sql, $params); | |
2346 | } else { | |
2347 | $tags = $DB->get_records_sql($sql, $params, 0, $numtags); | |
2348 | } | |
2349 | ||
2350 | // prepare the return | |
2351 | $return = array(); | |
2352 | if ($tags) { | |
2353 | // avoid print_tag_cloud()'s ksort upsetting ordering by setting the key here | |
2354 | foreach ($tags as $value) { | |
2355 | $return[] = $value; | |
2356 | } | |
2357 | } | |
2358 | ||
2359 | return $return; | |
2360 | ||
2361 | } | |
2362 | ||
2363 | /** | |
2364 | * Returns an ordered array of tags | |
2365 | * (replaces popular_tags_count() allowing sorting). | |
2366 | * | |
2367 | * @deprecated since 3.0 | |
2368 | * @package core_tag | |
2369 | * @category tag | |
2370 | * @param string $unused (optional) was selected sorting - moved to tag_print_cloud() | |
2371 | * @param int $numtags (optional) number of tags to display, default of 20 is set in the block, 0 returns all | |
2372 | * @return array | |
2373 | */ | |
2374 | function coursetag_get_all_tags($unused='', $numtags=0) { | |
2375 | debugging('Function coursetag_get_all_tag() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2376 | ||
2377 | global $CFG, $DB; | |
2378 | ||
2379 | // note that this selects all tags except for courses that are not visible | |
e11d7380 | 2380 | $sql = "SELECT id, name, isstandard, rawname, f.timemodified, flag, count |
0d1e5456 MG |
2381 | FROM {tag} t, |
2382 | (SELECT tagid, MAX(timemodified) as timemodified, COUNT(id) as count | |
2383 | FROM {tag_instance} WHERE tagid NOT IN | |
2384 | (SELECT tagid FROM {tag_instance} ti, {course} c | |
2385 | WHERE c.visible = 0 | |
2386 | AND ti.itemtype = 'course' | |
2387 | AND ti.itemid = c.id) | |
2388 | GROUP BY tagid) f | |
2389 | WHERE t.id = f.tagid | |
2390 | ORDER BY count DESC, name ASC"; | |
2391 | if ($numtags == 0) { | |
2392 | $tags = $DB->get_records_sql($sql); | |
2393 | } else { | |
2394 | $tags = $DB->get_records_sql($sql, null, 0, $numtags); | |
2395 | } | |
2396 | ||
2397 | $return = array(); | |
2398 | if ($tags) { | |
2399 | foreach ($tags as $value) { | |
2400 | $return[] = $value; | |
2401 | } | |
2402 | } | |
2403 | ||
2404 | return $return; | |
2405 | } | |
2406 | ||
2407 | /** | |
2408 | * Returns javascript for use in tags block and supporting pages | |
2409 | * | |
2410 | * @deprecated since 3.0 | |
2411 | * @package core_tag | |
2412 | * @category tag | |
2413 | * @return null | |
2414 | */ | |
2415 | function coursetag_get_jscript() { | |
2416 | debugging('Function coursetag_get_jscript() is deprecated and obsolete.', DEBUG_DEVELOPER); | |
2417 | return ''; | |
2418 | } | |
2419 | ||
2420 | /** | |
2421 | * Returns javascript to create the links in the tag block footer. | |
2422 | * | |
2423 | * @deprecated since 3.0 | |
2424 | * @package core_tag | |
2425 | * @category tag | |
2426 | * @param string $elementid the element to attach the footer to | |
2427 | * @param array $coursetagslinks links arrays each consisting of 'title', 'onclick' and 'text' elements | |
2428 | * @return string always returns a blank string | |
2429 | */ | |
2430 | function coursetag_get_jscript_links($elementid, $coursetagslinks) { | |
2431 | debugging('Function coursetag_get_jscript_links() is deprecated and obsolete.', DEBUG_DEVELOPER); | |
2432 | return ''; | |
2433 | } | |
2434 | ||
2435 | /** | |
2436 | * Returns all tags created by a user for a course | |
2437 | * | |
2438 | * @deprecated since 3.0 | |
2439 | * @package core_tag | |
2440 | * @category tag | |
2441 | * @param int $courseid tags are returned for the course that has this courseid | |
2442 | * @param int $userid return tags which were created by this user | |
2443 | */ | |
2444 | function coursetag_get_records($courseid, $userid) { | |
2445 | debugging('Function coursetag_get_records() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2446 | ||
2447 | global $CFG, $DB; | |
2448 | ||
2449 | $sql = "SELECT t.id, name, rawname | |
2450 | FROM {tag} t, {tag_instance} ti | |
2451 | WHERE t.id = ti.tagid | |
2452 | AND ti.tiuserid = :userid | |
2453 | AND ti.itemid = :courseid | |
2454 | ORDER BY name ASC"; | |
2455 | ||
2456 | return $DB->get_records_sql($sql, array('userid'=>$userid, 'courseid'=>$courseid)); | |
2457 | } | |
2458 | ||
2459 | /** | |
2460 | * Stores a tag for a course for a user | |
2461 | * | |
2462 | * @deprecated since 3.0 | |
2463 | * @package core_tag | |
2464 | * @category tag | |
2465 | * @param array $tags simple array of keywords to be stored | |
2466 | * @param int $courseid the id of the course we wish to store a tag for | |
2467 | * @param int $userid the id of the user we wish to store a tag for | |
2468 | * @param string $tagtype official or default only | |
2469 | * @param string $myurl (optional) for logging creation of course tags | |
2470 | */ | |
2471 | function coursetag_store_keywords($tags, $courseid, $userid=0, $tagtype='official', $myurl='') { | |
2472 | debugging('Function coursetag_store_keywords() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2473 | ||
2474 | global $CFG; | |
0d1e5456 MG |
2475 | |
2476 | if (is_array($tags) and !empty($tags)) { | |
c026a28d MG |
2477 | if ($tagtype === 'official') { |
2478 | $tagcoll = core_tag_area::get_collection('core', 'course'); | |
2479 | // 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. | |
2480 | core_tag_tag::create_if_missing($tagcoll, $tags, true); | |
2481 | } | |
0d1e5456 MG |
2482 | foreach ($tags as $tag) { |
2483 | $tag = trim($tag); | |
2484 | if (strlen($tag) > 0) { | |
c026a28d | 2485 | core_tag_tag::add_item_tag('core', 'course', $courseid, context_course::instance($courseid), $tag, $userid); |
0d1e5456 MG |
2486 | } |
2487 | } | |
2488 | } | |
2489 | ||
2490 | } | |
2491 | ||
2492 | /** | |
2493 | * Deletes a personal tag for a user for a course. | |
2494 | * | |
2495 | * @deprecated since 3.0 | |
2496 | * @package core_tag | |
2497 | * @category tag | |
2498 | * @param int $tagid the tag we wish to delete | |
2499 | * @param int $userid the user that the tag is associated with | |
2500 | * @param int $courseid the course that the tag is associated with | |
2501 | */ | |
2502 | function coursetag_delete_keyword($tagid, $userid, $courseid) { | |
2503 | debugging('Function coursetag_delete_keyword() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2504 | ||
c026a28d MG |
2505 | $tag = core_tag_tag::get($tagid); |
2506 | core_tag_tag::remove_item_tag('core', 'course', $courseid, $tag->rawname, $userid); | |
0d1e5456 MG |
2507 | } |
2508 | ||
2509 | /** | |
2510 | * Get courses tagged with a tag | |
2511 | * | |
2512 | * @deprecated since 3.0 | |
2513 | * @package core_tag | |
2514 | * @category tag | |
2515 | * @param int $tagid | |
2516 | * @return array of course objects | |
2517 | */ | |
2518 | function coursetag_get_tagged_courses($tagid) { | |
2519 | debugging('Function coursetag_get_tagged_courses() is deprecated. Userid is no longer used for tagging courses.', DEBUG_DEVELOPER); | |
2520 | ||
2521 | global $DB; | |
2522 | ||
2523 | $courses = array(); | |
2524 | ||
2525 | $ctxselect = context_helper::get_preload_record_columns_sql('ctx'); | |
2526 | ||
2527 | $sql = "SELECT c.*, $ctxselect | |
2528 | FROM {course} c | |
2529 | JOIN {tag_instance} t ON t.itemid = c.id | |
2530 | JOIN {context} ctx ON ctx.instanceid = c.id | |
2531 | WHERE t.tagid = :tagid AND | |
2532 | t.itemtype = 'course' AND | |
2533 | ctx.contextlevel = :contextlevel | |
2534 | ORDER BY c.sortorder ASC"; | |
2535 | $params = array('tagid' => $tagid, 'contextlevel' => CONTEXT_COURSE); | |
2536 | $rs = $DB->get_recordset_sql($sql, $params); | |
2537 | foreach ($rs as $course) { | |
2538 | context_helper::preload_from_record($course); | |
2539 | if ($course->visible == 1 || has_capability('moodle/course:viewhiddencourses', context_course::instance($course->id))) { | |
2540 | $courses[$course->id] = $course; | |
2541 | } | |
2542 | } | |
2543 | return $courses; | |
2544 | } | |
2545 | ||
2546 | /** | |
2547 | * Course tagging function used only during the deletion of a course (called by lib/moodlelib.php) to clean up associated tags | |
2548 | * | |
2549 | * @package core_tag | |
2550 | * @deprecated since 3.0 | |
2551 | * @param int $courseid the course we wish to delete tag instances from | |
2552 | * @param bool $showfeedback if we should output a notification of the delete to the end user | |
2553 | */ | |
2554 | function coursetag_delete_course_tags($courseid, $showfeedback=false) { | |
c026a28d MG |
2555 | debugging('Function coursetag_delete_course_tags() is deprecated. Use core_tag_tag::remove_all_item_tags().', DEBUG_DEVELOPER); |
2556 | ||
2557 | global $OUTPUT; | |
2558 | core_tag_tag::remove_all_item_tags('core', 'course', $courseid); | |
0d1e5456 | 2559 | |
c026a28d MG |
2560 | if ($showfeedback) { |
2561 | echo $OUTPUT->notification(get_string('deletedcoursetags', 'tag'), 'notifysuccess'); | |
2562 | } | |
2563 | } | |
0d1e5456 | 2564 | |
c026a28d MG |
2565 | /** |
2566 | * Set the type of a tag. At this time (version 2.2) the possible values are 'default' or 'official'. Official tags will be | |
2567 | * displayed separately "at tagging time" (while selecting the tags to apply to a record). | |
2568 | * | |
2569 | * @package core_tag | |
2570 | * @deprecated since 3.1 | |
2571 | * @param string $tagid tagid to modify | |
2572 | * @param string $type either 'default' or 'official' | |
2573 | * @return bool true on success, false otherwise | |
2574 | */ | |
2575 | function tag_type_set($tagid, $type) { | |
2576 | debugging('Function tag_type_set() is deprecated and can be replaced with use core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER); | |
2577 | if ($tag = core_tag_tag::get($tagid, '*')) { | |
e11d7380 | 2578 | return $tag->update(array('isstandard' => ($type === 'official') ? 1 : 0)); |
c026a28d MG |
2579 | } |
2580 | return false; | |
2581 | } | |
0d1e5456 | 2582 | |
c026a28d MG |
2583 | /** |
2584 | * Set the description of a tag | |
2585 | * | |
2586 | * @package core_tag | |
2587 | * @deprecated since 3.1 | |
2588 | * @param int $tagid the id of the tag | |
2589 | * @param string $description the tag's description string to be set | |
2590 | * @param int $descriptionformat the moodle text format of the description | |
2591 | * {@link http://docs.moodle.org/dev/Text_formats_2.0#Database_structure} | |
2592 | * @return bool true on success, false otherwise | |
2593 | */ | |
2594 | function tag_description_set($tagid, $description, $descriptionformat) { | |
2595 | debugging('Function tag_type_set() is deprecated and can be replaced with core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER); | |
2596 | if ($tag = core_tag_tag::get($tagid, '*')) { | |
2597 | return $tag->update(array('description' => $description, 'descriptionformat' => $descriptionformat)); | |
2598 | } | |
2599 | return false; | |
2600 | } | |
2601 | ||
2602 | /** | |
2603 | * Get the array of db record of tags associated to a record (instances). | |
2604 | * | |
2605 | * @package core_tag | |
2606 | * @deprecated since 3.1 | |
2607 | * @param string $record_type the record type for which we want to get the tags | |
2608 | * @param int $record_id the record id for which we want to get the tags | |
2609 | * @param string $type the tag type (either 'default' or 'official'). By default, all tags are returned. | |
2610 | * @param int $userid (optional) only required for course tagging | |
2611 | * @return array the array of tags | |
2612 | */ | |
2613 | function tag_get_tags($record_type, $record_id, $type=null, $userid=0) { | |
2614 | debugging('Method tag_get_tags() is deprecated and replaced with core_tag_tag::get_item_tags(). ' . | |
2615 | 'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER); | |
e11d7380 MG |
2616 | $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY : |
2617 | (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT)); | |
2618 | $tags = core_tag_tag::get_item_tags(null, $record_type, $record_id, $standardonly, $userid); | |
c026a28d MG |
2619 | $rv = array(); |
2620 | foreach ($tags as $id => $t) { | |
2621 | $rv[$id] = $t->to_object(); | |
2622 | } | |
2623 | return $rv; | |
2624 | } | |
2625 | ||
2626 | /** | |
2627 | * Get the array of tags display names, indexed by id. | |
2628 | * | |
2629 | * @package core_tag | |
2630 | * @deprecated since 3.1 | |
2631 | * @param string $record_type the record type for which we want to get the tags | |
2632 | * @param int $record_id the record id for which we want to get the tags | |
2633 | * @param string $type the tag type (either 'default' or 'official'). By default, all tags are returned. | |
2634 | * @return array the array of tags (with the value returned by core_tag_tag::make_display_name), indexed by id | |
2635 | */ | |
2636 | function tag_get_tags_array($record_type, $record_id, $type=null) { | |
2637 | debugging('Method tag_get_tags_array() is deprecated and replaced with core_tag_tag::get_item_tags_array(). ' . | |
2638 | 'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER); | |
e11d7380 MG |
2639 | $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY : |
2640 | (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT)); | |
2641 | return core_tag_tag::get_item_tags_array('', $record_type, $record_id, $standardonly); | |
c026a28d MG |
2642 | } |
2643 | ||
2644 | /** | |
2645 | * Get a comma-separated string of tags associated to a record. | |
2646 | * | |
2647 | * Use {@link tag_get_tags()} to get the same information in an array. | |
2648 | * | |
2649 | * @package core_tag | |
2650 | * @deprecated since 3.1 | |
2651 | * @param string $record_type the record type for which we want to get the tags | |
2652 | * @param int $record_id the record id for which we want to get the tags | |
2653 | * @param int $html either TAG_RETURN_HTML or TAG_RETURN_TEXT, depending on the type of output desired | |
2654 | * @param string $type either 'official' or 'default', if null, all tags are returned | |
2655 | * @return string the comma-separated list of tags. | |
2656 | */ | |
2657 | function tag_get_tags_csv($record_type, $record_id, $html=null, $type=null) { | |
2658 | global $CFG, $OUTPUT; | |
2659 | debugging('Method tag_get_tags_csv() is deprecated. Instead you should use either ' . | |
2660 | 'core_tag_tag::get_item_tags_array() or $OUTPUT->tag_list(core_tag_tag::get_item_tags()). ' . | |
2661 | 'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER); | |
e11d7380 MG |
2662 | $standardonly = ($type === 'official' ? core_tag_tag::STANDARD_ONLY : |
2663 | (!empty($type) ? core_tag_tag::NOT_STANDARD_ONLY : core_tag_tag::BOTH_STANDARD_AND_NOT)); | |
c026a28d | 2664 | if ($html != TAG_RETURN_TEXT) { |
e11d7380 | 2665 | return $OUTPUT->tag_list(core_tag_tag::get_item_tags('', $record_type, $record_id, $standardonly), ''); |
c026a28d | 2666 | } else { |
e11d7380 | 2667 | return join(', ', core_tag_tag::get_item_tags_array('', $record_type, $record_id, $standardonly, 0, false)); |
c026a28d MG |
2668 | } |
2669 | } | |
2670 | ||
2671 | /** | |
2672 | * Get an array of tag ids associated to a record. | |
2673 | * | |
2674 | * @package core_tag | |
2675 | * @deprecated since 3.1 | |
2676 | * @param string $record_type the record type for which we want to get the tags | |
2677 | * @param int $record_id the record id for which we want to get the tags | |
2678 | * @return array tag ids, indexed and sorted by 'ordering' | |
2679 | */ | |
2680 | function tag_get_tags_ids($record_type, $record_id) { | |
2681 | debugging('Method tag_get_tags_ids() is deprecated. Please consider using core_tag_tag::get_item_tags() or similar methods.', DEBUG_DEVELOPER); | |
2682 | $tag_ids = array(); | |
2683 | $tagobjects = core_tag_tag::get_item_tags(null, $record_type, $record_id); | |
2684 | foreach ($tagobjects as $tagobject) { | |
2685 | $tag = $tagobject->to_object(); | |
2686 | if ( array_key_exists($tag->ordering, $tag_ids) ) { | |
2687 | $tag->ordering++; | |
0d1e5456 | 2688 | } |
c026a28d | 2689 | $tag_ids[$tag->ordering] = $tag->id; |
0d1e5456 | 2690 | } |
c026a28d MG |
2691 | ksort($tag_ids); |
2692 | return $tag_ids; | |
2693 | } | |
0d1e5456 | 2694 | |
c026a28d MG |
2695 | /** |
2696 | * Returns the database ID of a set of tags. | |
2697 | * | |
2698 | * @deprecated since 3.1 | |
2699 | * @param mixed $tags one tag, or array of tags, to look for. | |
2700 | * @param bool $return_value specify the type of the returned value. Either TAG_RETURN_OBJECT, or TAG_RETURN_ARRAY (default). | |
2701 | * If TAG_RETURN_ARRAY is specified, an array will be returned even if only one tag was passed in $tags. | |
2702 | * @return mixed tag-indexed array of ids (or objects, if second parameter is TAG_RETURN_OBJECT), or only an int, if only one tag | |
2703 | * is given *and* the second parameter is null. No value for a key means the tag wasn't found. | |
2704 | */ | |
2705 | function tag_get_id($tags, $return_value = null) { | |
2706 | global $CFG, $DB; | |
2707 | 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(). ' . | |
2708 | 'You need to specify tag collection when retrieving tag by name', DEBUG_DEVELOPER); | |
2709 | ||
2710 | if (!is_array($tags)) { | |
2711 | if(is_null($return_value) || $return_value == TAG_RETURN_OBJECT) { | |
2712 | if ($tagobject = core_tag_tag::get_by_name(core_tag_collection::get_default(), $tags)) { | |
2713 | return $tagobject->id; | |
2714 | } else { | |
2715 | return 0; | |
2716 | } | |
2717 | } | |
2718 | $tags = array($tags); | |
2719 | } | |
2720 | ||
2721 | $records = core_tag_tag::get_by_name_bulk(core_tag_collection::get_default(), $tags, | |
2722 | $return_value == TAG_RETURN_OBJECT ? '*' : 'id, name'); | |
2723 | foreach ($records as $name => $record) { | |
2724 | if ($return_value != TAG_RETURN_OBJECT) { | |
2725 | $records[$name] = $record->id ? $record->id : null; | |
2726 | } else { | |
2727 | $records[$name] = $record->to_object(); | |
2728 | } | |
2729 | } | |
2730 | return $records; | |
2731 | } | |
2732 | ||
2733 | /** | |
2734 | * Change the "value" of a tag, and update the associated 'name'. | |
2735 | * | |
2736 | * @package core_tag | |
2737 | * @deprecated since 3.1 | |
2738 | * @param int $tagid the id of the tag to modify | |
2739 | * @param string $newrawname the new rawname | |
2740 | * @return bool true on success, false otherwise | |
2741 | */ | |
2742 | function tag_rename($tagid, $newrawname) { | |
2743 | debugging('Function tag_rename() is deprecated and may be replaced with core_tag_tag::get($tagid)->update().', DEBUG_DEVELOPER); | |
2744 | if ($tag = core_tag_tag::get($tagid, '*')) { | |
2745 | return $tag->update(array('rawname' => $newrawname)); | |
2746 | } | |
2747 | return false; | |
2748 | } | |
2749 | ||
2750 | /** | |
2751 | * Delete one instance of a tag. If the last instance was deleted, it will also delete the tag, unless its type is 'official'. | |
2752 | * | |
2753 | * @package core_tag | |
2754 | * @deprecated since 3.1 | |
2755 | * @param string $record_type the type of the record for which to remove the instance | |
2756 | * @param int $record_id the id of the record for which to remove the instance | |
2757 | * @param int $tagid the tagid that needs to be removed | |
2758 | * @param int $userid (optional) the userid | |
2759 | * @return bool true on success, false otherwise | |
2760 | */ | |
2761 | function tag_delete_instance($record_type, $record_id, $tagid, $userid = null) { | |
2762 | debugging('Function tag_delete_instance() is deprecated and replaced with core_tag_tag::remove_item_tag() instead. ' . | |
2763 | 'Component is required for retrieving instances', DEBUG_DEVELOPER); | |
2764 | $tag = core_tag_tag::get($tagid); | |
2765 | core_tag_tag::remove_item_tag('', $record_type, $record_id, $tag->rawname, $userid); | |
2766 | } | |
2767 | ||
2768 | /** | |
2769 | * Find all records tagged with a tag of a given type ('post', 'user', etc.) | |
2770 | * | |
2771 | * @package core_tag | |
2a723541 | 2772 | * @deprecated since 3.1 |
c026a28d MG |
2773 | * @category tag |
2774 | * @param string $tag tag to look for | |
2775 | * @param string $type type to restrict search to. If null, every matching record will be returned | |
2776 | * @param int $limitfrom (optional, required if $limitnum is set) return a subset of records, starting at this point. | |
2777 | * @param int $limitnum (optional, required if $limitfrom is set) return a subset comprising this many records. | |
2778 | * @return array of matching objects, indexed by record id, from the table containing the type requested | |
2779 | */ | |
2780 | function tag_find_records($tag, $type, $limitfrom='', $limitnum='') { | |
2781 | debugging('Function tag_find_records() is deprecated and replaced with core_tag_tag::get_by_name()->get_tagged_items(). '. | |
2782 | 'You need to specify tag collection when retrieving tag by name', DEBUG_DEVELOPER); | |
2783 | ||
2784 | if (!$tag || !$type) { | |
2785 | return array(); | |
2786 | } | |
2787 | ||
2788 | $tagobject = core_tag_tag::get_by_name(core_tag_area::get_collection('', $type), $tag); | |
2789 | return $tagobject->get_tagged_items('', $type, $limitfrom, $limitnum); | |
2790 | } | |
2791 | ||
2792 | /** | |
2793 | * Adds one or more tag in the database. This function should not be called directly : you should | |
2794 | * use tag_set. | |
2795 | * | |
2796 | * @package core_tag | |
2797 | * @deprecated since 3.1 | |
2798 | * @param mixed $tags one tag, or an array of tags, to be created | |
2799 | * @param string $type type of tag to be created ("default" is the default value and "official" is the only other supported | |
2800 | * value at this time). An official tag is kept even if there are no records tagged with it. | |
2801 | * @return array $tags ids indexed by their lowercase normalized names. Any boolean false in the array indicates an error while | |
2802 | * adding the tag. | |
2803 | */ | |
2804 | function tag_add($tags, $type="default") { | |
2805 | debugging('Function tag_add() is deprecated. You can use core_tag_tag::create_if_missing(), however it should not be necessary ' . | |
2806 | 'since tags are created automatically when assigned to items', DEBUG_DEVELOPER); | |
2807 | if (!is_array($tags)) { | |
2808 | $tags = array($tags); | |
2809 | } | |
e11d7380 MG |
2810 | $objects = core_tag_tag::create_if_missing(core_tag_collection::get_default(), $tags, |
2811 | $type === 'official'); | |
c026a28d MG |
2812 | |
2813 | // New function returns the tags in different format, for BC we keep the format that this function used to have. | |
2814 | $rv = array(); | |
2815 | foreach ($objects as $name => $tagobject) { | |
2816 | if (isset($tagobject->id)) { | |
2817 | $rv[$tagobject->name] = $tagobject->id; | |
2818 | } else { | |
2819 | $rv[$name] = false; | |
2820 | } | |
2821 | } | |
2822 | return $rv; | |
2823 | } | |
2824 | ||
2825 | /** | |
2826 | * Assigns a tag to a record; if the record already exists, the time and ordering will be updated. | |
2827 | * | |
2828 | * @package core_tag | |
2829 | * @deprecated since 3.1 | |
2830 | * @param string $record_type the type of the record that will be tagged | |
2831 | * @param int $record_id the id of the record that will be tagged | |
2832 | * @param string $tagid the tag id to set on the record. | |
2833 | * @param int $ordering the order of the instance for this record | |
2834 | * @param int $userid (optional) only required for course tagging | |
2835 | * @param string|null $component the component that was tagged | |
2836 | * @param int|null $contextid the context id of where this tag was assigned | |
2837 | * @return bool true on success, false otherwise | |
2838 | */ | |
2839 | function tag_assign($record_type, $record_id, $tagid, $ordering, $userid = 0, $component = null, $contextid = null) { | |
2840 | global $DB; | |
2841 | $message = 'Function tag_assign() is deprecated. Use core_tag_tag::set_item_tags() or core_tag_tag::add_item_tag() instead. ' . | |
2842 | 'Tag instance ordering should not be set manually'; | |
2843 | if ($component === null || $contextid === null) { | |
2844 | $message .= '. You should specify the component and contextid of the item being tagged in your call to tag_assign.'; | |
2845 | } | |
2846 | debugging($message, DEBUG_DEVELOPER); | |
2847 | ||
2848 | if ($contextid) { | |
2849 | $context = context::instance_by_id($contextid); | |
2850 | } else { | |
2851 | $context = context_system::instance(); | |
2852 | } | |
2853 | ||
2854 | // Get the tag. | |
2855 | $tag = $DB->get_record('tag', array('id' => $tagid), 'name, rawname', MUST_EXIST); | |
2856 | ||
2857 | $taginstanceid = core_tag_tag::add_item_tag($component, $record_type, $record_id, $context, $tag->rawname, $userid); | |
2858 | ||
2859 | // Alter the "ordering" of tag_instance. This should never be done manually and only remains here for the backward compatibility. | |
2860 | $taginstance = new stdClass(); | |
2861 | $taginstance->id = $taginstanceid; | |
2862 | $taginstance->ordering = $ordering; | |
2863 | $taginstance->timemodified = time(); | |
2864 | ||
2865 | $DB->update_record('tag_instance', $taginstance); | |
2866 | ||
2867 | return true; | |
2868 | } | |
2869 | ||
2870 | /** | |
2871 | * Count how many records are tagged with a specific tag. | |
2872 | * | |
2873 | * @package core_tag | |
2874 | * @deprecated since 3.1 | |
2875 | * @param string $record_type record to look for ('post', 'user', etc.) | |
2876 | * @param int $tagid is a single tag id | |
2877 | * @return int number of mathing tags. | |
2878 | */ | |
2879 | function tag_record_count($record_type, $tagid) { | |
2880 | debugging('Method tag_record_count() is deprecated and replaced with core_tag_tag::get($tagid)->count_tagged_items(). '. | |
2881 | 'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER); | |
2882 | return core_tag_tag::get($tagid)->count_tagged_items('', $record_type); | |
2883 | } | |
2884 | ||
2885 | /** | |
2886 | * Determine if a record is tagged with a specific tag | |
2887 | * | |
2888 | * @package core_tag | |
2889 | * @deprecated since 3.1 | |
2890 | * @param string $record_type the record type to look for | |
2891 | * @param int $record_id the record id to look for | |
2892 | * @param string $tag a tag name | |
2893 | * @return bool/int true if it is tagged, 0 (false) otherwise | |
2894 | */ | |
2895 | function tag_record_tagged_with($record_type, $record_id, $tag) { | |
2896 | debugging('Method tag_record_tagged_with() is deprecated and replaced with core_tag_tag::get($tagid)->is_item_tagged_with(). '. | |
2897 | 'Component is now required when retrieving tag instances.', DEBUG_DEVELOPER); | |
2898 | return core_tag_tag::is_item_tagged_with('', $record_type, $record_id, $tag); | |
2899 | } | |
2900 | ||
2901 | /** | |
2902 | * Flag a tag as inappropriate. | |
2903 | * | |
2904 | * @deprecated since 3.1 | |
2905 | * @param int|array $tagids a single tagid, or an array of tagids | |
2906 | */ | |
2907 | function tag_set_flag($tagids) { | |
2908 | debugging('Function tag_set_flag() is deprecated and replaced with core_tag_tag::get($tagid)->flag().', DEBUG_DEVELOPER); | |
2909 | $tagids = (array) $tagids; | |
2910 | foreach ($tagids as $tagid) { | |
2911 | if ($tag = core_tag_tag::get($tagid, '*')) { | |
2912 | $tag->flag(); | |
2913 | } | |
2914 | } | |
2915 | } | |
2916 | ||
2917 | /** | |
2918 | * Remove the inappropriate flag on a tag. | |
2919 | * | |
2920 | * @deprecated since 3.1 | |
2921 | * @param int|array $tagids a single tagid, or an array of tagids | |
2922 | */ | |
2923 | function tag_unset_flag($tagids) { | |
2924 | debugging('Function tag_unset_flag() is deprecated and replaced with core_tag_tag::get($tagid)->reset_flag().', DEBUG_DEVELOPER); | |
2925 | $tagids = (array) $tagids; | |
2926 | foreach ($tagids as $tagid) { | |
2927 | if ($tag = core_tag_tag::get($tagid, '*')) { | |
2928 | $tag->reset_flag(); | |
2929 | } | |
2930 | } | |
2931 | } | |
2932 | ||
2933 | /** | |
2934 | * Prints or returns a HTML tag cloud with varying classes styles depending on the popularity and type of each tag. | |
2935 | * | |
2936 | * @deprecated since 3.1 | |
2937 | * | |
2938 | * @param array $tagset Array of tags to display | |
2939 | * @param int $nr_of_tags Limit for the number of tags to return/display, used if $tagset is null | |
2940 | * @param bool $return if true the function will return the generated tag cloud instead of displaying it. | |
2941 | * @param string $sort (optional) selected sorting, default is alpha sort (name) also timemodified or popularity | |
2942 | * @return string|null a HTML string or null if this function does the output | |
2943 | */ | |
2944 | function tag_print_cloud($tagset=null, $nr_of_tags=150, $return=false, $sort='') { | |
2945 | global $OUTPUT; | |
2946 | ||
2947 | debugging('Function tag_print_cloud() is deprecated and replaced with function core_tag_collection::get_tag_cloud(), ' | |
2948 | . 'templateable core_tag\output\tagcloud and template core_tag/tagcloud.', DEBUG_DEVELOPER); | |
2949 | ||
2950 | // Set up sort global - used to pass sort type into core_tag_collection::cloud_sort through usort() avoiding multiple sort functions. | |
2951 | if ($sort == 'popularity') { | |
2952 | $sort = 'count'; | |
2953 | } else if ($sort == 'date') { | |
2954 | $sort = 'timemodified'; | |
2955 | } else { | |
2956 | $sort = 'name'; | |
2957 | } | |
2958 | ||
2959 | if (is_null($tagset)) { | |
2960 | // No tag set received, so fetch tags from database. | |
2961 | // Always add query by tagcollid even when it's not known to make use of the table index. | |
e11d7380 | 2962 | $tagcloud = core_tag_collection::get_tag_cloud(0, false, $nr_of_tags, $sort); |
c026a28d MG |
2963 | } else { |
2964 | $tagsincloud = $tagset; | |
2965 | ||
2966 | $etags = array(); | |
2967 | foreach ($tagsincloud as $tag) { | |
2968 | $etags[] = $tag; | |
2969 | } | |
2970 | ||
2971 | core_tag_collection::$cloudsortfield = $sort; | |
2972 | usort($tagsincloud, "core_tag_collection::cloud_sort"); | |
2973 | ||
2974 | $tagcloud = new \core_tag\output\tagcloud($tagsincloud); | |
2975 | } | |
2976 | ||
2977 | $output = $OUTPUT->render_from_template('core_tag/tagcloud', $tagcloud->export_for_template($OUTPUT)); | |
2978 | if ($return) { | |
2979 | return $output; | |
2980 | } else { | |
2981 | echo $output; | |
0d1e5456 MG |
2982 | } |
2983 | } | |
a27c42ee MG |
2984 | |
2985 | /** | |
2986 | * Function that returns tags that start with some text, for use by the autocomplete feature | |
2987 | * | |
2988 | * @package core_tag | |
2989 | * @deprecated since 3.0 | |
2990 | * @access private | |
2991 | * @param string $text string that the tag names will be matched against | |
2992 | * @return mixed an array of objects, or false if no records were found or an error occured. | |
2993 | */ | |
2994 | function tag_autocomplete($text) { | |
2995 | debugging('Function tag_autocomplete() is deprecated without replacement. ' . | |
2996 | 'New form element "tags" does proper autocomplete.', DEBUG_DEVELOPER); | |
2997 | global $DB; | |
2998 | return $DB->get_records_sql("SELECT tg.id, tg.name, tg.rawname | |
2999 | FROM {tag} tg | |
3000 | WHERE tg.name LIKE ?", array(core_text::strtolower($text)."%")); | |
3001 | } | |
c026a28d MG |
3002 | |
3003 | /** | |
3004 | * Prints a box with the description of a tag and its related tags | |
3005 | * | |
3006 | * @package core_tag | |
3007 | * @deprecated since 3.1 | |
3008 | * @param stdClass $tag_object | |
3009 | * @param bool $return if true the function will return the generated tag cloud instead of displaying it. | |
3010 | * @return string/null a HTML box showing a description of the tag object and it's relationsips or null if output is done directly | |
3011 | * in the function. | |
3012 | */ | |
3013 | function tag_print_description_box($tag_object, $return=false) { | |
3014 | global $USER, $CFG, $OUTPUT; | |
3015 | require_once($CFG->libdir.'/filelib.php'); | |
3016 | ||
3017 | debugging('Function tag_print_description_box() is deprecated without replacement. ' . | |
3018 | 'See core_tag_renderer for similar code.', DEBUG_DEVELOPER); | |
3019 | ||
3020 | $relatedtags = array(); | |
3021 | if ($tag = core_tag_tag::get($tag_object->id)) { | |
3022 | $relatedtags = $tag->get_related_tags(); | |
3023 | } | |
3024 | ||
3025 | $content = !empty($tag_object->description); | |
3026 | $output = ''; | |
3027 | ||
3028 | if ($content) { | |
3029 | $output .= $OUTPUT->box_start('generalbox tag-description'); | |
3030 | } | |
3031 | ||
3032 | if (!empty($tag_object->description)) { | |
3033 | $options = new stdClass(); | |
3034 | $options->para = false; | |
3035 | $options->overflowdiv = true; | |
3036 | $tag_object->description = file_rewrite_pluginfile_urls($tag_object->description, 'pluginfile.php', context_system::instance()->id, 'tag', 'description', $tag_object->id); | |
3037 | $output .= format_text($tag_object->description, $tag_object->descriptionformat, $options); | |
3038 | } | |
3039 | ||
3040 | if ($content) { | |
3041 | $output .= $OUTPUT->box_end(); | |
3042 | } | |
3043 | ||
3044 | if ($relatedtags) { | |
3045 | $output .= $OUTPUT->tag_list($relatedtags, get_string('relatedtags', 'tag'), 'tag-relatedtags'); | |
3046 | } | |
3047 | ||
3048 | if ($return) { | |
3049 | return $output; | |
3050 | } else { | |
3051 | echo $output; | |
3052 | } | |
3053 | } | |
3054 | ||
3055 | /** | |
3056 | * Prints a box that contains the management links of a tag | |
3057 | * | |
3058 | * @deprecated since 3.1 | |
3059 | * @param core_tag_tag|stdClass $tag_object | |
3060 | * @param bool $return if true the function will return the generated tag cloud instead of displaying it. | |
3061 | * @return string|null a HTML string or null if this function does the output | |
3062 | */ | |
3063 | function tag_print_management_box($tag_object, $return=false) { | |
3064 | global $USER, $CFG, $OUTPUT; | |
3065 | ||
3066 | debugging('Function tag_print_description_box() is deprecated without replacement. ' . | |
3067 | 'See core_tag_renderer for similar code.', DEBUG_DEVELOPER); | |
3068 | ||
3069 | $tagname = core_tag_tag::make_display_name($tag_object); | |
3070 | $output = ''; | |
3071 | ||
3072 | if (!isguestuser()) { | |
3073 | $output .= $OUTPUT->box_start('box','tag-management-box'); | |
3074 | $systemcontext = context_system::instance(); | |
3075 | $links = array(); | |
3076 | ||
3077 | // Add a link for users to add/remove this from their interests | |
3078 | if (core_tag_tag::is_enabled('core', 'user') && core_tag_area::get_collection('core', 'user') == $tag_object->tagcollid) { | |
3079 | if (core_tag_tag::is_item_tagged_with('core', 'user', $USER->id, $tag_object->name)) { | |
3080 | $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=removeinterest&sesskey='. sesskey() . | |
3081 | '&tag='. rawurlencode($tag_object->name) .'">'. | |
3082 | get_string('removetagfrommyinterests', 'tag', $tagname) .'</a>'; | |
3083 | } else { | |
3084 | $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=addinterest&sesskey='. sesskey() . | |
3085 | '&tag='. rawurlencode($tag_object->name) .'">'. | |
3086 | get_string('addtagtomyinterests', 'tag', $tagname) .'</a>'; | |
3087 | } | |
3088 | } | |
3089 | ||
3090 | // Flag as inappropriate link. Only people with moodle/tag:flag capability. | |
3091 | if (has_capability('moodle/tag:flag', $systemcontext)) { | |
3092 | $links[] = '<a href="'. $CFG->wwwroot .'/tag/user.php?action=flaginappropriate&sesskey='. | |
3093 | sesskey() . '&id='. $tag_object->id . '">'. get_string('flagasinappropriate', | |
3094 | 'tag', rawurlencode($tagname)) .'</a>'; | |
3095 | } | |
3096 | ||
3097 | // Edit tag: Only people with moodle/tag:edit capability who either have it as an interest or can manage tags | |
3098 | if (has_capability('moodle/tag:edit', $systemcontext) || | |
3099 | has_capability('moodle/tag:manage', $systemcontext)) { | |
3100 | $links[] = '<a href="' . $CFG->wwwroot . '/tag/edit.php?id=' . $tag_object->id . '">' . | |
3101 | get_string('edittag', 'tag') . '</a>'; | |
3102 | } | |
3103 | ||
3104 | $output .= implode(' | ', $links); | |
3105 | $output .= $OUTPUT->box_end(); | |
3106 | } | |
3107 | ||
3108 | if ($return) { | |
3109 | return $output; | |
3110 | } else { | |
3111 | echo $output; | |
3112 | } | |
3113 | } | |
3114 | ||
3115 | /** | |
3116 | * Prints the tag search box | |
3117 | * | |
3118 | * @deprecated since 3.1 | |
3119 | * @param bool $return if true return html string | |
3120 | * @return string|null a HTML string or null if this function does the output | |
3121 | */ | |
3122 | function tag_print_search_box($return=false) { | |
3123 | global $CFG, $OUTPUT; | |
3124 | ||
3125 | debugging('Function tag_print_search_box() is deprecated without replacement. ' . | |
3126 | 'See core_tag_renderer for similar code.', DEBUG_DEVELOPER); | |
3127 | ||
3128 | $query = optional_param('query', '', PARAM_RAW); | |
3129 | ||
3130 | $output = $OUTPUT->box_start('','tag-search-box'); | |
3131 | $output .= '<form action="'.$CFG->wwwroot.'/tag/search.php" style="display:inline">'; | |
3132 | $output .= '<div>'; | |
3133 | $output .= '<label class="accesshide" for="searchform_search">'.get_string('searchtags', 'tag').'</label>'; | |
3134 | $output .= '<input id="searchform_search" name="query" type="text" size="40" value="'.s($query).'" />'; | |
3135 | $output .= '<button id="searchform_button" type="submit">'. get_string('search', 'tag') .'</button><br />'; | |
3136 | $output .= '</div>'; | |
3137 | $output .= '</form>'; | |
3138 | $output .= $OUTPUT->box_end(); | |
3139 | ||
3140 | if ($return) { | |
3141 | return $output; | |
3142 | } | |
3143 | else { | |
3144 | echo $output; | |
3145 | } | |
3146 | } | |
3147 | ||
3148 | /** | |
3149 | * Prints the tag search results | |
3150 | * | |
3151 | * @deprecated since 3.1 | |
3152 | * @param string $query text that tag names will be matched against | |
3153 | * @param int $page current page | |
3154 | * @param int $perpage nr of users displayed per page | |
3155 | * @param bool $return if true return html string | |
3156 | * @return string|null a HTML string or null if this function does the output | |
3157 | */ | |
3158 | function tag_print_search_results($query, $page, $perpage, $return=false) { | |
3159 | global $CFG, $USER, $OUTPUT; | |
3160 | ||
3161 | debugging('Function tag_print_search_results() is deprecated without replacement. ' . | |
3162 | 'In /tag/search.php the search results are printed using the core_tag/tagcloud template.', DEBUG_DEVELOPER); | |
3163 | ||
3164 | $query = clean_param($query, PARAM_TAG); | |
3165 | ||
3166 | $count = count(tag_find_tags($query, false)); | |
3167 | $tags = array(); | |
3168 | ||
3169 | if ( $found_tags = tag_find_tags($query, true, $page * $perpage, $perpage) ) { | |
3170 | $tags = array_values($found_tags); | |
3171 | } | |
3172 | ||
3173 | $baseurl = $CFG->wwwroot.'/tag/search.php?query='. rawurlencode($query); | |
3174 | $output = ''; | |
3175 | ||
3176 | // link "Add $query to my interests" | |
3177 | $addtaglink = ''; | |
3178 | if (core_tag_tag::is_enabled('core', 'user') && !core_tag_tag::is_item_tagged_with('core', 'user', $USER->id, $query)) { | |
3179 | $addtaglink = html_writer::link(new moodle_url('/tag/user.php', array('action' => 'addinterest', 'sesskey' => sesskey(), | |
3180 | 'tag' => $query)), get_string('addtagtomyinterests', 'tag', s($query))); | |
3181 | } | |
3182 | ||
3183 | if ( !empty($tags) ) { // there are results to display!! | |
3184 | $output .= $OUTPUT->heading(get_string('searchresultsfor', 'tag', htmlspecialchars($query)) ." : {$count}", 3, 'main'); | |
3185 | ||
3186 | //print a link "Add $query to my interests" | |
3187 | if (!empty($addtaglink)) { | |
3188 | $output .= $OUTPUT->box($addtaglink, 'box', 'tag-management-box'); | |
3189 | } | |
3190 | ||
3191 | $nr_of_lis_per_ul = 6; | |
3192 | $nr_of_uls = ceil( sizeof($tags) / $nr_of_lis_per_ul ); | |
3193 | ||
3194 | $output .= '<ul id="tag-search-results">'; | |
3195 | for($i = 0; $i < $nr_of_uls; $i++) { | |
3196 | foreach (array_slice($tags, $i * $nr_of_lis_per_ul, $nr_of_lis_per_ul) as $tag) { | |
3197 | $output .= '<li>'; | |
3198 | $tag_link = html_writer::link(core_tag_tag::make_url($tag->tagcollid, $tag->rawname), | |
3199 | core_tag_tag::make_display_name($tag)); | |
3200 | $output .= $tag_link; | |
3201 | $output .= '</li>'; | |
3202 | } | |
3203 | } | |
3204 | $output .= '</ul>'; | |
3205 | $output .= '<div> </div>'; // <-- small layout hack in order to look good in Firefox | |
3206 | ||
3207 | $output .= $OUTPUT->paging_bar($count, $page, $perpage, $baseurl); | |
3208 | } | |
3209 | else { //no results were found!! | |
3210 | $output .= $OUTPUT->heading(get_string('noresultsfor', 'tag', htmlspecialchars($query)), 3, 'main'); | |
3211 | ||
3212 | //print a link "Add $query to my interests" | |
3213 | if (!empty($addtaglink)) { | |
3214 | $output .= $OUTPUT->box($addtaglink, 'box', 'tag-management-box'); | |
3215 | } | |
3216 | } | |
3217 | ||
3218 | if ($return) { | |
3219 | return $output; | |
3220 | } | |
3221 | else { | |
3222 | echo $output; | |
3223 | } | |
3224 | } | |
3225 | ||
3226 | /** | |
3227 | * Prints a table of the users tagged with the tag passed as argument | |
3228 | * | |
3229 | * @deprecated since 3.1 | |
3230 | * @param stdClass $tagobject the tag we wish to return data for | |
3231 | * @param int $limitfrom (optional, required if $limitnum is set) prints users starting at this point. | |
3232 | * @param int $limitnum (optional, required if $limitfrom is set) prints this many users. | |
3233 | * @param bool $return if true return html string | |
3234 | * @return string|null a HTML string or null if this function does the output | |
3235 | */ | |
3236 | function tag_print_tagged_users_table($tagobject, $limitfrom='', $limitnum='', $return=false) { | |
3237 | ||
3238 | debugging('Function tag_print_tagged_users_table() is deprecated without replacement. ' . | |
3239 | 'See core_user_renderer for similar code.', DEBUG_DEVELOPER); | |
3240 | ||
3241 | //List of users with this tag | |
3242 | $tagobject = core_tag_tag::get($tagobject->id); | |
3243 | $userlist = $tagobject->get_tagged_items('core', 'user', $limitfrom, $limitnum); | |
3244 | ||
3245 | $output = tag_print_user_list($userlist, true); | |
3246 | ||
3247 | if ($return) { | |
3248 | return $output; | |
3249 | } | |
3250 | else { | |
3251 | echo $output; | |
3252 | } | |
3253 | } | |
3254 | ||
3255 | /** | |
3256 | * Prints an individual user box | |
3257 | * | |
3258 | * @deprecated since 3.1 | |
3259 | * @param user_object $user (contains the following fields: id, firstname, lastname and picture) | |
3260 | * @param bool $return if true return html string | |
3261 | * @return string|null a HTML string or null if this function does the output | |
3262 | */ | |
3263 | function tag_print_user_box($user, $return=false) { | |
3264 | global $CFG, $OUTPUT; | |
3265 | ||
3266 | debugging('Function tag_print_user_box() is deprecated without replacement. ' . | |
3267 | 'See core_user_renderer for similar code.', DEBUG_DEVELOPER); | |
3268 | ||
3269 | $usercontext = context_user::instance($user->id); | |
3270 | $profilelink = ''; | |
3271 | ||
3272 | if ($usercontext and (has_capability('moodle/user:viewdetails', $usercontext) || has_coursecontact_role($user->id))) { | |
3273 | $profilelink = $CFG->wwwroot .'/user/view.php?id='. $user->id; | |
3274 | } | |
3275 | ||
3276 | $output = $OUTPUT->box_start('user-box', 'user'. $user->id); | |
3277 | $fullname = fullname($user); | |
3278 | $alt = ''; | |
3279 | ||
3280 | if (!empty($profilelink)) { | |
3281 | $output .= '<a href="'. $profilelink .'">'; | |
3282 | $alt = $fullname; | |
3283 | } | |
3284 | ||
3285 | $output .= $OUTPUT->user_picture($user, array('size'=>100)); | |
3286 | $output .= '<br />'; | |
3287 | ||
3288 | if (!empty($profilelink)) { | |
3289 | $output .= '</a>'; | |
3290 | } | |
3291 | ||
3292 | //truncate name if it's too big | |
3293 | if (core_text::strlen($fullname) > 26) { | |
3294 | $fullname = core_text::substr($fullname, 0, 26) .'...'; | |
3295 | } | |
3296 | ||
3297 | $output .= '<strong>'. $fullname .'</strong>'; | |
3298 | $output .= $OUTPUT->box_end(); | |
3299 | ||
3300 | if ($return) { | |
3301 | return $output; | |
3302 | } | |
3303 | else { | |
3304 | echo $output; | |
3305 | } | |
3306 | } | |
3307 | ||
3308 | /** | |
3309 | * Prints a list of users | |
3310 | * | |
3311 | * @deprecated since 3.1 | |
3312 | * @param array $userlist an array of user objects | |
3313 | * @param bool $return if true return html string, otherwise output the result | |
3314 | * @return string|null a HTML string or null if this function does the output | |
3315 | */ | |
3316 | function tag_print_user_list($userlist, $return=false) { | |
3317 | ||
3318 | debugging('Function tag_print_user_list() is deprecated without replacement. ' . | |
3319 | 'See core_user_renderer for similar code.', DEBUG_DEVELOPER); | |
3320 | ||
3321 | $output = '<div><ul class="inline-list">'; | |
3322 | ||
3323 | foreach ($userlist as $user){ | |
3324 | $output .= '<li>'. tag_print_user_box($user, true) ."</li>\n"; | |
3325 | } | |
3326 | $output .= "</ul></div>\n"; | |
3327 | ||
3328 | if ($return) { | |
3329 | return $output; | |
3330 | } | |
3331 | else { | |
3332 | echo $output; | |
3333 | } | |
3334 | } | |
3335 | ||
3336 | /** | |
3337 | * Function that returns the name that should be displayed for a specific tag | |
3338 | * | |
3339 | * @package core_tag | |
3340 | * @category tag | |
3341 | * @deprecated since 3.1 | |
3342 | * @param stdClass|core_tag_tag $tagobject a line out of tag table, as returned by the adobd functions | |
3343 | * @param int $html TAG_RETURN_HTML (default) will return htmlspecialchars encoded string, TAG_RETURN_TEXT will not encode. | |
3344 | * @return string | |
3345 | */ | |
3346 | function tag_display_name($tagobject, $html=TAG_RETURN_HTML) { | |
3347 | debugging('Function tag_display_name() is deprecated. Use core_tag_tag::make_display_name().', DEBUG_DEVELOPER); | |
3348 | if (!isset($tagobject->name)) { | |
3349 | return ''; | |
3350 | } | |
3351 | return core_tag_tag::make_display_name($tagobject, $html != TAG_RETURN_TEXT); | |
3352 | } | |
3353 | ||
3354 | /** | |
3355 | * Function that normalizes a list of tag names. | |
3356 | * | |
3357 | * @package core_tag | |
3358 | * @deprecated since 3.1 | |
3359 | * @param array/string $rawtags array of tags, or a single tag. | |
3360 | * @param int $case case to use for returned value (default: lower case). Either TAG_CASE_LOWER (default) or TAG_CASE_ORIGINAL | |
3361 | * @return array lowercased normalized tags, indexed by the normalized tag, in the same order as the original array. | |
3362 | * (Eg: 'Banana' => 'banana'). | |
3363 | */ | |
3364 | function tag_normalize($rawtags, $case = TAG_CASE_LOWER) { | |
3365 | debugging('Function tag_normalize() is deprecated. Use core_tag_tag::normalize().', DEBUG_DEVELOPER); | |
3366 | ||
3367 | if ( !is_array($rawtags) ) { | |
3368 | $rawtags = array($rawtags); | |
3369 | } | |
3370 | ||
3371 | return core_tag_tag::normalize($rawtags, $case == TAG_CASE_LOWER); | |
3372 | } | |
3373 | ||
3374 | /** | |
3375 | * Get a comma-separated list of tags related to another tag. | |
3376 | * | |
3377 | * @package core_tag | |
3378 | * @deprecated since 3.1 | |
3379 | * @param array $related_tags the array returned by tag_get_related_tags | |
3380 | * @param int $html either TAG_RETURN_HTML (default) or TAG_RETURN_TEXT : return html links, or just text. | |
3381 | * @return string comma-separated list | |
3382 | */ | |
3383 | function tag_get_related_tags_csv($related_tags, $html=TAG_RETURN_HTML) { | |
3384 | global $OUTPUT; | |
3385 | debugging('Method tag_get_related_tags_csv() is deprecated. Consider ' | |
3386 | . 'looping through array or using $OUTPUT->tag_list(core_tag_tag::get_item_tags())', | |
3387 | DEBUG_DEVELOPER); | |
3388 | if ($html != TAG_RETURN_TEXT) { | |
3389 | return $OUTPUT->tag_list($related_tags, ''); | |
3390 | } | |
3391 | ||
3392 | $tagsnames = array(); | |
3393 | foreach ($related_tags as $tag) { | |
3394 | $tagsnames[] = core_tag_tag::make_display_name($tag, false); | |
3395 | } | |
3396 | return implode(', ', $tagsnames); | |
3397 | } | |
3398 | ||
3399 | /** | |
3400 | * Used to require that the return value from a function is an array. | |
3401 | * Only used in the deprecated function {@link tag_get_id()} | |
3402 | * @deprecated since 3.1 | |
3403 | */ | |
3404 | define('TAG_RETURN_ARRAY', 0); | |
3405 | /** | |
3406 | * Used to require that the return value from a function is an object. | |
3407 | * Only used in the deprecated function {@link tag_get_id()} | |
3408 | * @deprecated since 3.1 | |
3409 | */ | |
3410 | define('TAG_RETURN_OBJECT', 1); | |
3411 | /** | |
3412 | * Use to specify that HTML free text is expected to be returned from a function. | |
3413 | * Only used in deprecated functions {@link tag_get_tags_csv()}, {@link tag_display_name()}, | |
3414 | * {@link tag_get_related_tags_csv()} | |
3415 | * @deprecated since 3.1 | |
3416 | */ | |
3417 | define('TAG_RETURN_TEXT', 2); | |
3418 | /** | |
3419 | * Use to specify that encoded HTML is expected to be returned from a function. | |
3420 | * Only used in deprecated functions {@link tag_get_tags_csv()}, {@link tag_display_name()}, | |
3421 | * {@link tag_get_related_tags_csv()} | |
3422 | * @deprecated since 3.1 | |
3423 | */ | |
3424 | define('TAG_RETURN_HTML', 3); | |
3425 | ||
3426 | /** | |
3427 | * Used to specify that we wish a lowercased string to be returned | |
3428 | * Only used in deprecated function {@link tag_normalize()} | |
3429 | * @deprecated since 3.1 | |
3430 | */ | |
3431 | define('TAG_CASE_LOWER', 0); | |
3432 | /** | |
3433 | * Used to specify that we do not wish the case of the returned string to change | |
3434 | * Only used in deprecated function {@link tag_normalize()} | |
3435 | * @deprecated since 3.1 | |
3436 | */ | |
3437 | define('TAG_CASE_ORIGINAL', 1); | |
3438 | ||
3439 | /** | |
3440 | * Used to specify that we want all related tags returned, no matter how they are related. | |
3441 | * Only used in deprecated function {@link tag_get_related_tags()} | |
3442 | * @deprecated since 3.1 | |
3443 | */ | |
3444 | define('TAG_RELATED_ALL', 0); | |
3445 | /** | |
3446 | * Used to specify that we only want back tags that were manually related. | |
3447 | * Only used in deprecated function {@link tag_get_related_tags()} | |
3448 | * @deprecated since 3.1 | |
3449 | */ | |
3450 | define('TAG_RELATED_MANUAL', 1); | |
3451 | /** | |
3452 | * Used to specify that we only want back tags where the relationship was automatically correlated. | |
3453 | * Only used in deprecated function {@link tag_get_related_tags()} | |
3454 | * @deprecated since 3.1 | |
3455 | */ | |
3456 | define('TAG_RELATED_CORRELATED', 2); | |
3457 | ||
3458 | /** | |
3459 | * Set the tags assigned to a record. This overwrites the current tags. | |
3460 | * | |
3461 | * This function is meant to be fed the string coming up from the user interface, which contains all tags assigned to a record. | |
3462 | * | |
3463 | * Due to API change $component and $contextid are now required. Instead of | |
3464 | * calling this function you can use {@link core_tag_tag::set_item_tags()} or | |
3465 | * {@link core_tag_tag::set_related_tags()} | |
3466 | * | |
3467 | * @package core_tag | |
3468 | * @deprecated since 3.1 | |
3469 | * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, 'tag' for tags, etc.) | |
3470 | * @param int $itemid the id of the record to tag | |
3471 | * @param array $tags the array of tags to set on the record. If given an empty array, all tags will be removed. | |
3472 | * @param string|null $component the component that was tagged | |
3473 | * @param int|null $contextid the context id of where this tag was assigned | |