Commit | Line | Data |
---|---|---|
449611af | 1 | <?php |
2 | ||
b868d3d9 | 3 | // This file is part of Moodle - http://moodle.org/ |
4 | // | |
449611af | 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. | |
b868d3d9 | 14 | // |
449611af | 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/>. | |
f9903ed0 | 17 | |
7cf1c7bd | 18 | /** |
19 | * Library of functions for web output | |
20 | * | |
21 | * Library of all general-purpose Moodle PHP functions and constants | |
22 | * that produce HTML output | |
23 | * | |
24 | * Other main libraries: | |
25 | * - datalib.php - functions that access the database. | |
26 | * - moodlelib.php - general-purpose Moodle functions. | |
449611af | 27 | * |
78bfb562 PS |
28 | * @package core |
29 | * @subpackage lib | |
30 | * @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com} | |
31 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
7cf1c7bd | 32 | */ |
772e78be | 33 | |
78bfb562 PS |
34 | defined('MOODLE_INTERNAL') || die(); |
35 | ||
0095d5cd | 36 | /// Constants |
37 | ||
c1d57101 | 38 | /// Define text formatting types ... eventually we can add Wiki, BBcode etc |
7cf1c7bd | 39 | |
40 | /** | |
41 | * Does all sorts of transformations and filtering | |
42 | */ | |
b0ccd3fb | 43 | define('FORMAT_MOODLE', '0'); // Does all sorts of transformations and filtering |
7cf1c7bd | 44 | |
45 | /** | |
46 | * Plain HTML (with some tags stripped) | |
47 | */ | |
b0ccd3fb | 48 | define('FORMAT_HTML', '1'); // Plain HTML (with some tags stripped) |
7cf1c7bd | 49 | |
50 | /** | |
51 | * Plain text (even tags are printed in full) | |
52 | */ | |
b0ccd3fb | 53 | define('FORMAT_PLAIN', '2'); // Plain text (even tags are printed in full) |
7cf1c7bd | 54 | |
55 | /** | |
56 | * Wiki-formatted text | |
6a6495ff | 57 | * Deprecated: left here just to note that '3' is not used (at the moment) |
58 | * and to catch any latent wiki-like text (which generates an error) | |
7cf1c7bd | 59 | */ |
b0ccd3fb | 60 | define('FORMAT_WIKI', '3'); // Wiki-formatted text |
7cf1c7bd | 61 | |
62 | /** | |
63 | * Markdown-formatted text http://daringfireball.net/projects/markdown/ | |
64 | */ | |
b0ccd3fb | 65 | define('FORMAT_MARKDOWN', '4'); // Markdown-formatted text http://daringfireball.net/projects/markdown/ |
0095d5cd | 66 | |
827b2f7a | 67 | /** |
68 | * A moodle_url comparison using this flag will return true if the base URLs match, params are ignored | |
69 | */ | |
70 | define('URL_MATCH_BASE', 0); | |
71 | /** | |
72 | * A moodle_url comparison using this flag will return true if the base URLs match and the params of url1 are part of url2 | |
73 | */ | |
74 | define('URL_MATCH_PARAMS', 1); | |
75 | /** | |
ea85e1ee | 76 | * A moodle_url comparison using this flag will return true if the two URLs are identical, except for the order of the params |
827b2f7a | 77 | */ |
78 | define('URL_MATCH_EXACT', 2); | |
7cf1c7bd | 79 | |
0095d5cd | 80 | /// Functions |
81 | ||
7cf1c7bd | 82 | /** |
83 | * Add quotes to HTML characters | |
84 | * | |
85 | * Returns $var with HTML characters (like "<", ">", etc.) properly quoted. | |
86 | * This function is very similar to {@link p()} | |
87 | * | |
449611af | 88 | * @todo Remove obsolete param $obsolete if not used anywhere |
89 | * | |
7cf1c7bd | 90 | * @param string $var the string potentially containing HTML characters |
b4cf9371 | 91 | * @param boolean $obsolete no longer used. |
7cf1c7bd | 92 | * @return string |
93 | */ | |
b4cf9371 | 94 | function s($var, $obsolete = false) { |
d4a42ff4 | 95 | |
c676fe67 | 96 | if ($var === '0' or $var === false or $var === 0) { |
63e554d0 | 97 | return '0'; |
3662bce5 | 98 | } |
d4a42ff4 | 99 | |
e728447d | 100 | return preg_replace("/&#(\d+|x[0-7a-fA-F]+);/i", "&#$1;", htmlspecialchars($var, ENT_QUOTES, 'UTF-8', true)); |
f9903ed0 | 101 | } |
102 | ||
7cf1c7bd | 103 | /** |
104 | * Add quotes to HTML characters | |
105 | * | |
d48b00b4 | 106 | * Prints $var with HTML characters (like "<", ">", etc.) properly quoted. |
449611af | 107 | * This function simply calls {@link s()} |
108 | * @see s() | |
109 | * | |
110 | * @todo Remove obsolete param $obsolete if not used anywhere | |
7cf1c7bd | 111 | * |
112 | * @param string $var the string potentially containing HTML characters | |
b4cf9371 | 113 | * @param boolean $obsolete no longer used. |
7cf1c7bd | 114 | * @return string |
115 | */ | |
b4cf9371 | 116 | function p($var, $obsolete = false) { |
117 | echo s($var, $obsolete); | |
f9903ed0 | 118 | } |
119 | ||
0d1cd0ea | 120 | /** |
121 | * Does proper javascript quoting. | |
449611af | 122 | * |
5ce73257 | 123 | * Do not use addslashes anymore, because it does not work when magic_quotes_sybase is enabled. |
124 | * | |
449611af | 125 | * @param mixed $var String, Array, or Object to add slashes to |
0d1cd0ea | 126 | * @return mixed quoted result |
127 | */ | |
128 | function addslashes_js($var) { | |
129 | if (is_string($var)) { | |
130 | $var = str_replace('\\', '\\\\', $var); | |
131 | $var = str_replace(array('\'', '"', "\n", "\r", "\0"), array('\\\'', '\\"', '\\n', '\\r', '\\0'), $var); | |
4702be4e | 132 | $var = str_replace('</', '<\/', $var); // XHTML compliance |
0d1cd0ea | 133 | } else if (is_array($var)) { |
134 | $var = array_map('addslashes_js', $var); | |
135 | } else if (is_object($var)) { | |
136 | $a = get_object_vars($var); | |
137 | foreach ($a as $key=>$value) { | |
138 | $a[$key] = addslashes_js($value); | |
139 | } | |
140 | $var = (object)$a; | |
141 | } | |
142 | return $var; | |
143 | } | |
7cf1c7bd | 144 | |
7cf1c7bd | 145 | /** |
146 | * Remove query string from url | |
147 | * | |
148 | * Takes in a URL and returns it without the querystring portion | |
149 | * | |
150 | * @param string $url the url which may have a query string attached | |
449611af | 151 | * @return string The remaining URL |
7cf1c7bd | 152 | */ |
153 | function strip_querystring($url) { | |
f9903ed0 | 154 | |
b9b8ab69 | 155 | if ($commapos = strpos($url, '?')) { |
156 | return substr($url, 0, $commapos); | |
157 | } else { | |
158 | return $url; | |
159 | } | |
f9903ed0 | 160 | } |
161 | ||
7cf1c7bd | 162 | /** |
c8135a35 | 163 | * Returns the URL of the HTTP_REFERER, less the querystring portion if required |
449611af | 164 | * |
165 | * @uses $_SERVER | |
9ea04325 | 166 | * @param boolean $stripquery if true, also removes the query part of the url. |
fa9f6bf6 | 167 | * @return string The resulting referer or empty string |
7cf1c7bd | 168 | */ |
c8135a35 | 169 | function get_referer($stripquery=true) { |
d90ffc1f | 170 | if (isset($_SERVER['HTTP_REFERER'])) { |
c8135a35 | 171 | if ($stripquery) { |
172 | return strip_querystring($_SERVER['HTTP_REFERER']); | |
173 | } else { | |
174 | return $_SERVER['HTTP_REFERER']; | |
175 | } | |
d90ffc1f | 176 | } else { |
5ce73257 | 177 | return ''; |
d90ffc1f | 178 | } |
f9903ed0 | 179 | } |
180 | ||
c1d57101 | 181 | |
7cf1c7bd | 182 | /** |
183 | * Returns the name of the current script, WITH the querystring portion. | |
449611af | 184 | * |
185 | * This function is necessary because PHP_SELF and REQUEST_URI and SCRIPT_NAME | |
7cf1c7bd | 186 | * return different things depending on a lot of things like your OS, Web |
187 | * server, and the way PHP is compiled (ie. as a CGI, module, ISAPI, etc.) | |
d48b00b4 | 188 | * <b>NOTE:</b> This function returns false if the global variables needed are not set. |
189 | * | |
449611af | 190 | * @return mixed String, or false if the global variables needed are not set |
7cf1c7bd | 191 | */ |
b03fc392 | 192 | function me() { |
193 | global $ME; | |
194 | return $ME; | |
f9903ed0 | 195 | } |
196 | ||
7cf1c7bd | 197 | /** |
f0202ae9 | 198 | * Guesses the full URL of the current script. |
449611af | 199 | * |
f0202ae9 PS |
200 | * This function is using $PAGE->url, but may fall back to $FULLME which |
201 | * is constructed from PHP_SELF and REQUEST_URI or SCRIPT_NAME | |
449611af | 202 | * |
f0202ae9 | 203 | * @return mixed full page URL string or false if unknown |
7cf1c7bd | 204 | */ |
f9903ed0 | 205 | function qualified_me() { |
f0202ae9 PS |
206 | global $FULLME, $PAGE, $CFG; |
207 | ||
208 | if (isset($PAGE) and $PAGE->has_set_url()) { | |
209 | // this is the only recommended way to find out current page | |
210 | return $PAGE->url->out(false); | |
211 | ||
212 | } else { | |
213 | if ($FULLME === null) { | |
214 | // CLI script most probably | |
215 | return false; | |
216 | } | |
217 | if (!empty($CFG->sslproxy)) { | |
218 | // return only https links when using SSL proxy | |
219 | return preg_replace('/^http:/', 'https:', $FULLME, 1); | |
220 | } else { | |
221 | return $FULLME; | |
222 | } | |
223 | } | |
f9903ed0 | 224 | } |
225 | ||
360e503e | 226 | /** |
227 | * Class for creating and manipulating urls. | |
84e3d2cc | 228 | * |
449611af | 229 | * It can be used in moodle pages where config.php has been included without any further includes. |
230 | * | |
49c8c8d2 | 231 | * It is useful for manipulating urls with long lists of params. |
fa9f6bf6 | 232 | * One situation where it will be useful is a page which links to itself to perform various actions |
449611af | 233 | * and / or to process form data. A moodle_url object : |
49c8c8d2 | 234 | * can be created for a page to refer to itself with all the proper get params being passed from page call to |
235 | * page call and methods can be used to output a url including all the params, optionally adding and overriding | |
449611af | 236 | * params and can also be used to |
237 | * - output the url without any get params | |
49c8c8d2 | 238 | * - and output the params as hidden fields to be output within a form |
449611af | 239 | * |
728ebac7 | 240 | * @link http://docs.moodle.org/dev/lib/weblib.php_moodle_url See short write up here |
449611af | 241 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later |
242 | * @package moodlecore | |
360e503e | 243 | */ |
244 | class moodle_url { | |
449611af | 245 | /** |
a6855934 PS |
246 | * Scheme, ex.: http, https |
247 | * @var string | |
248 | */ | |
249 | protected $scheme = ''; | |
250 | /** | |
251 | * hostname | |
449611af | 252 | * @var string |
449611af | 253 | */ |
7ceb61d8 | 254 | protected $host = ''; |
a6855934 PS |
255 | /** |
256 | * Port number, empty means default 80 or 443 in case of http | |
257 | * @var unknown_type | |
258 | */ | |
7ceb61d8 | 259 | protected $port = ''; |
a6855934 PS |
260 | /** |
261 | * Username for http auth | |
262 | * @var string | |
263 | */ | |
7ceb61d8 | 264 | protected $user = ''; |
a6855934 PS |
265 | /** |
266 | * Password for http auth | |
267 | * @var string | |
268 | */ | |
7ceb61d8 | 269 | protected $pass = ''; |
a6855934 | 270 | /** |
7dff555f | 271 | * Script path |
a6855934 PS |
272 | * @var string |
273 | */ | |
7ceb61d8 | 274 | protected $path = ''; |
7dff555f PS |
275 | /** |
276 | * Optional slash argument value | |
277 | * @var string | |
278 | */ | |
279 | protected $slashargument = ''; | |
449611af | 280 | /** |
a6855934 PS |
281 | * Anchor, may be also empty, null means none |
282 | * @var string | |
283 | */ | |
284 | protected $anchor = null; | |
285 | /** | |
286 | * Url parameters as associative array | |
49c8c8d2 | 287 | * @var array |
449611af | 288 | */ |
7ceb61d8 | 289 | protected $params = array(); // Associative array of query string params |
84e3d2cc | 290 | |
360e503e | 291 | /** |
a6855934 | 292 | * Create new instance of moodle_url. |
84e3d2cc | 293 | * |
a6855934 PS |
294 | * @param moodle_url|string $url - moodle_url means make a copy of another |
295 | * moodle_url and change parameters, string means full url or shortened | |
296 | * form (ex.: '/course/view.php'). It is strongly encouraged to not include | |
2284c694 TH |
297 | * query string because it may result in double encoded values. Use the |
298 | * $params instead. For admin URLs, just use /admin/script.php, this | |
299 | * class takes care of the $CFG->admin issue. | |
a6855934 | 300 | * @param array $params these params override current params or add new |
360e503e | 301 | */ |
a6855934 PS |
302 | public function __construct($url, array $params = null) { |
303 | global $CFG; | |
2b3fcef9 | 304 | |
a6855934 | 305 | if ($url instanceof moodle_url) { |
75781f87 | 306 | $this->scheme = $url->scheme; |
307 | $this->host = $url->host; | |
308 | $this->port = $url->port; | |
309 | $this->user = $url->user; | |
310 | $this->pass = $url->pass; | |
ad52c04f | 311 | $this->path = $url->path; |
7dff555f | 312 | $this->slashargument = $url->slashargument; |
75781f87 | 313 | $this->params = $url->params; |
a6855934 | 314 | $this->anchor = $url->anchor; |
2b3fcef9 | 315 | |
75781f87 | 316 | } else { |
a6855934 PS |
317 | // detect if anchor used |
318 | $apos = strpos($url, '#'); | |
319 | if ($apos !== false) { | |
320 | $anchor = substr($url, $apos); | |
321 | $anchor = ltrim($anchor, '#'); | |
322 | $this->set_anchor($anchor); | |
323 | $url = substr($url, 0, $apos); | |
360e503e | 324 | } |
a6855934 PS |
325 | |
326 | // normalise shortened form of our url ex.: '/course/view.php' | |
327 | if (strpos($url, '/') === 0) { | |
328 | // we must not use httpswwwroot here, because it might be url of other page, | |
329 | // devs have to use httpswwwroot explicitly when creating new moodle_url | |
330 | $url = $CFG->wwwroot.$url; | |
75781f87 | 331 | } |
a6855934 PS |
332 | |
333 | // now fix the admin links if needed, no need to mess with httpswwwroot | |
334 | if ($CFG->admin !== 'admin') { | |
335 | if (strpos($url, "$CFG->wwwroot/admin/") === 0) { | |
336 | $url = str_replace("$CFG->wwwroot/admin/", "$CFG->wwwroot/$CFG->admin/", $url); | |
337 | } | |
338 | } | |
339 | ||
340 | // parse the $url | |
341 | $parts = parse_url($url); | |
342 | if ($parts === false) { | |
75781f87 | 343 | throw new moodle_exception('invalidurl'); |
360e503e | 344 | } |
7ceb61d8 | 345 | if (isset($parts['query'])) { |
a6855934 PS |
346 | // note: the values may not be correctly decoded, |
347 | // url parameters should be always passed as array | |
24a905f9 | 348 | parse_str(str_replace('&', '&', $parts['query']), $this->params); |
360e503e | 349 | } |
350 | unset($parts['query']); | |
7ceb61d8 | 351 | foreach ($parts as $key => $value) { |
360e503e | 352 | $this->$key = $value; |
353 | } | |
7dff555f PS |
354 | |
355 | // detect slashargument value from path - we do not support directory names ending with .php | |
356 | $pos = strpos($this->path, '.php/'); | |
357 | if ($pos !== false) { | |
358 | $this->slashargument = substr($this->path, $pos + 4); | |
359 | $this->path = substr($this->path, 0, $pos + 4); | |
360 | } | |
360e503e | 361 | } |
2b3fcef9 | 362 | |
75781f87 | 363 | $this->params($params); |
84e3d2cc | 364 | } |
7ceb61d8 | 365 | |
360e503e | 366 | /** |
2b3fcef9 | 367 | * Add an array of params to the params for this url. |
449611af | 368 | * |
369 | * The added params override existing ones if they have the same name. | |
360e503e | 370 | * |
f8065dd2 | 371 | * @param array $params Defaults to null. If null then returns all params. |
449611af | 372 | * @return array Array of Params for url. |
360e503e | 373 | */ |
2b3fcef9 PS |
374 | public function params(array $params = null) { |
375 | $params = (array)$params; | |
376 | ||
377 | foreach ($params as $key=>$value) { | |
378 | if (is_int($key)) { | |
d8ae33a9 | 379 | throw new coding_exception('Url parameters can not have numeric keys!'); |
2b3fcef9 | 380 | } |
27d6ab57 | 381 | if (!is_string($value)) { |
382 | if (is_array($value)) { | |
383 | throw new coding_exception('Url parameters values can not be arrays!'); | |
384 | } | |
385 | if (is_object($value) and !method_exists($value, '__toString')) { | |
386 | throw new coding_exception('Url parameters values can not be objects, unless __toString() is defined!'); | |
387 | } | |
2b3fcef9 PS |
388 | } |
389 | $this->params[$key] = (string)$value; | |
c1f41c59 | 390 | } |
2b3fcef9 | 391 | return $this->params; |
360e503e | 392 | } |
84e3d2cc | 393 | |
360e503e | 394 | /** |
49c8c8d2 | 395 | * Remove all params if no arguments passed. |
396 | * Remove selected params if arguments are passed. | |
449611af | 397 | * |
398 | * Can be called as either remove_params('param1', 'param2') | |
75781f87 | 399 | * or remove_params(array('param1', 'param2')). |
360e503e | 400 | * |
75781f87 | 401 | * @param mixed $params either an array of param names, or a string param name, |
402 | * @param string $params,... any number of additional param names. | |
2b3fcef9 | 403 | * @return array url parameters |
360e503e | 404 | */ |
2b3fcef9 | 405 | public function remove_params($params = null) { |
75781f87 | 406 | if (!is_array($params)) { |
407 | $params = func_get_args(); | |
408 | } | |
409 | foreach ($params as $param) { | |
2b3fcef9 | 410 | unset($this->params[$param]); |
360e503e | 411 | } |
2b3fcef9 PS |
412 | return $this->params; |
413 | } | |
414 | ||
415 | /** | |
416 | * Remove all url parameters | |
417 | * @param $params | |
418 | * @return void | |
419 | */ | |
420 | public function remove_all_params($params = null) { | |
421 | $this->params = array(); | |
7dff555f | 422 | $this->slashargument = ''; |
360e503e | 423 | } |
424 | ||
425 | /** | |
2b3fcef9 | 426 | * Add a param to the params for this url. |
449611af | 427 | * |
2b3fcef9 | 428 | * The added param overrides existing one if they have the same name. |
360e503e | 429 | * |
430 | * @param string $paramname name | |
2b3fcef9 PS |
431 | * @param string $newvalue Param value. If new value specified current value is overriden or parameter is added |
432 | * @return mixed string parameter value, null if parameter does not exist | |
360e503e | 433 | */ |
2b3fcef9 PS |
434 | public function param($paramname, $newvalue = '') { |
435 | if (func_num_args() > 1) { | |
436 | // set new value | |
437 | $this->params(array($paramname=>$newvalue)); | |
438 | } | |
439 | if (isset($this->params[$paramname])) { | |
5762b36e | 440 | return $this->params[$paramname]; |
cf615522 | 441 | } else { |
442 | return null; | |
c1f41c59 | 443 | } |
360e503e | 444 | } |
445 | ||
2b3fcef9 PS |
446 | /** |
447 | * Merges parameters and validates them | |
448 | * @param array $overrideparams | |
449 | * @return array merged parameters | |
450 | */ | |
451 | protected function merge_overrideparams(array $overrideparams = null) { | |
452 | $overrideparams = (array)$overrideparams; | |
453 | $params = $this->params; | |
454 | foreach ($overrideparams as $key=>$value) { | |
455 | if (is_int($key)) { | |
cdefaa86 | 456 | throw new coding_exception('Overridden parameters can not have numeric keys!'); |
2b3fcef9 PS |
457 | } |
458 | if (is_array($value)) { | |
cdefaa86 | 459 | throw new coding_exception('Overridden parameters values can not be arrays!'); |
2b3fcef9 PS |
460 | } |
461 | if (is_object($value) and !method_exists($value, '__toString')) { | |
cdefaa86 | 462 | throw new coding_exception('Overridden parameters values can not be objects, unless __toString() is defined!'); |
2b3fcef9 PS |
463 | } |
464 | $params[$key] = (string)$value; | |
465 | } | |
466 | return $params; | |
467 | } | |
468 | ||
7ceb61d8 | 469 | /** |
470 | * Get the params as as a query string. | |
8afba50b | 471 | * This method should not be used outside of this method. |
449611af | 472 | * |
8afba50b | 473 | * @param boolean $escaped Use & as params separator instead of plain & |
7ceb61d8 | 474 | * @param array $overrideparams params to add to the output params, these |
475 | * override existing ones with the same name. | |
476 | * @return string query string that can be added to a url. | |
477 | */ | |
8afba50b | 478 | public function get_query_string($escaped = true, array $overrideparams = null) { |
360e503e | 479 | $arr = array(); |
27d6ab57 | 480 | if ($overrideparams !== null) { |
481 | $params = $this->merge_overrideparams($overrideparams); | |
482 | } else { | |
483 | $params = $this->params; | |
484 | } | |
7ceb61d8 | 485 | foreach ($params as $key => $val) { |
ab82976f TH |
486 | if (is_array($val)) { |
487 | foreach ($val as $index => $value) { | |
488 | $arr[] = rawurlencode($key.'['.$index.']')."=".rawurlencode($value); | |
489 | } | |
490 | } else { | |
491 | $arr[] = rawurlencode($key)."=".rawurlencode($val); | |
492 | } | |
360e503e | 493 | } |
c7f5e16a | 494 | if ($escaped) { |
495 | return implode('&', $arr); | |
496 | } else { | |
497 | return implode('&', $arr); | |
498 | } | |
360e503e | 499 | } |
7ceb61d8 | 500 | |
2b3fcef9 PS |
501 | /** |
502 | * Shortcut for printing of encoded URL. | |
503 | * @return string | |
504 | */ | |
505 | public function __toString() { | |
b9bc2019 | 506 | return $this->out(true); |
2b3fcef9 PS |
507 | } |
508 | ||
360e503e | 509 | /** |
510 | * Output url | |
84e3d2cc | 511 | * |
c7f5e16a | 512 | * If you use the returned URL in HTML code, you want the escaped ampersands. If you use |
513 | * the returned URL in HTTP headers, you want $escaped=false. | |
514 | * | |
c7f5e16a | 515 | * @param boolean $escaped Use & as params separator instead of plain & |
b9bc2019 | 516 | * @param array $overrideparams params to add to the output url, these override existing ones with the same name. |
449611af | 517 | * @return string Resulting URL |
360e503e | 518 | */ |
b9bc2019 PS |
519 | public function out($escaped = true, array $overrideparams = null) { |
520 | if (!is_bool($escaped)) { | |
521 | debugging('Escape parameter must be of type boolean, '.gettype($escaped).' given instead.'); | |
522 | } | |
523 | ||
7dff555f | 524 | $uri = $this->out_omit_querystring().$this->slashargument; |
244a32c6 | 525 | |
8afba50b | 526 | $querystring = $this->get_query_string($escaped, $overrideparams); |
7dff555f | 527 | if ($querystring !== '') { |
eb788065 PS |
528 | $uri .= '?' . $querystring; |
529 | } | |
530 | if (!is_null($this->anchor)) { | |
531 | $uri .= '#'.$this->anchor; | |
360e503e | 532 | } |
a6855934 | 533 | |
84e3d2cc | 534 | return $uri; |
360e503e | 535 | } |
7ceb61d8 | 536 | |
eb788065 PS |
537 | /** |
538 | * Returns url without parameters, everything before '?'. | |
5c6ee6ec DM |
539 | * |
540 | * @param bool $includeanchor if {@link self::anchor} is defined, should it be returned? | |
eb788065 PS |
541 | * @return string |
542 | */ | |
5c6ee6ec DM |
543 | public function out_omit_querystring($includeanchor = false) { |
544 | ||
eb788065 PS |
545 | $uri = $this->scheme ? $this->scheme.':'.((strtolower($this->scheme) == 'mailto') ? '':'//'): ''; |
546 | $uri .= $this->user ? $this->user.($this->pass? ':'.$this->pass:'').'@':''; | |
547 | $uri .= $this->host ? $this->host : ''; | |
548 | $uri .= $this->port ? ':'.$this->port : ''; | |
549 | $uri .= $this->path ? $this->path : ''; | |
5c6ee6ec DM |
550 | if ($includeanchor and !is_null($this->anchor)) { |
551 | $uri .= '#' . $this->anchor; | |
552 | } | |
553 | ||
eb788065 | 554 | return $uri; |
b5d0cafc PS |
555 | } |
556 | ||
827b2f7a | 557 | /** |
558 | * Compares this moodle_url with another | |
559 | * See documentation of constants for an explanation of the comparison flags. | |
560 | * @param moodle_url $url The moodle_url object to compare | |
561 | * @param int $matchtype The type of comparison (URL_MATCH_BASE, URL_MATCH_PARAMS, URL_MATCH_EXACT) | |
562 | * @return boolean | |
563 | */ | |
564 | public function compare(moodle_url $url, $matchtype = URL_MATCH_EXACT) { | |
c705a24e | 565 | |
eb788065 PS |
566 | $baseself = $this->out_omit_querystring(); |
567 | $baseother = $url->out_omit_querystring(); | |
bf6c37c7 | 568 | |
569 | // Append index.php if there is no specific file | |
570 | if (substr($baseself,-1)=='/') { | |
571 | $baseself .= 'index.php'; | |
572 | } | |
573 | if (substr($baseother,-1)=='/') { | |
574 | $baseother .= 'index.php'; | |
575 | } | |
576 | ||
577 | // Compare the two base URLs | |
578 | if ($baseself != $baseother) { | |
827b2f7a | 579 | return false; |
580 | } | |
581 | ||
582 | if ($matchtype == URL_MATCH_BASE) { | |
583 | return true; | |
584 | } | |
585 | ||
586 | $urlparams = $url->params(); | |
587 | foreach ($this->params() as $param => $value) { | |
588 | if ($param == 'sesskey') { | |
589 | continue; | |
590 | } | |
591 | if (!array_key_exists($param, $urlparams) || $urlparams[$param] != $value) { | |
592 | return false; | |
593 | } | |
594 | } | |
595 | ||
596 | if ($matchtype == URL_MATCH_PARAMS) { | |
597 | return true; | |
598 | } | |
599 | ||
600 | foreach ($urlparams as $param => $value) { | |
601 | if ($param == 'sesskey') { | |
602 | continue; | |
603 | } | |
604 | if (!array_key_exists($param, $this->params()) || $this->param($param) != $value) { | |
605 | return false; | |
606 | } | |
607 | } | |
608 | ||
609 | return true; | |
610 | } | |
13b0b271 SH |
611 | |
612 | /** | |
613 | * Sets the anchor for the URI (the bit after the hash) | |
a6855934 | 614 | * @param string $anchor null means remove previous |
13b0b271 SH |
615 | */ |
616 | public function set_anchor($anchor) { | |
a6855934 PS |
617 | if (is_null($anchor)) { |
618 | // remove | |
619 | $this->anchor = null; | |
620 | } else if ($anchor === '') { | |
621 | // special case, used as empty link | |
622 | $this->anchor = ''; | |
623 | } else if (preg_match('|[a-zA-Z\_\:][a-zA-Z0-9\_\-\.\:]*|', $anchor)) { | |
624 | // Match the anchor against the NMTOKEN spec | |
625 | $this->anchor = $anchor; | |
626 | } else { | |
627 | // bad luck, no valid anchor found | |
628 | $this->anchor = null; | |
13b0b271 SH |
629 | } |
630 | } | |
7dff555f | 631 | |
4e40406d PS |
632 | /** |
633 | * Sets the url slashargument value | |
634 | * @param string $path usually file path | |
635 | * @param string $parameter name of page parameter if slasharguments not supported | |
636 | * @param bool $supported usually null, then it depends on $CFG->slasharguments, use true or false for other servers | |
637 | * @return void | |
638 | */ | |
f28ee49e | 639 | public function set_slashargument($path, $parameter = 'file', $supported = NULL) { |
4e40406d PS |
640 | global $CFG; |
641 | if (is_null($supported)) { | |
642 | $supported = $CFG->slasharguments; | |
643 | } | |
644 | ||
645 | if ($supported) { | |
646 | $parts = explode('/', $path); | |
647 | $parts = array_map('rawurlencode', $parts); | |
648 | $path = implode('/', $parts); | |
649 | $this->slashargument = $path; | |
650 | unset($this->params[$parameter]); | |
651 | ||
652 | } else { | |
653 | $this->slashargument = ''; | |
654 | $this->params[$parameter] = $path; | |
655 | } | |
656 | } | |
657 | ||
7dff555f PS |
658 | // == static factory methods == |
659 | ||
660 | /** | |
acdb9177 PS |
661 | * General moodle file url. |
662 | * @param string $urlbase the script serving the file | |
663 | * @param string $path | |
7dff555f PS |
664 | * @param bool $forcedownload |
665 | * @return moodle_url | |
666 | */ | |
f28ee49e | 667 | public static function make_file_url($urlbase, $path, $forcedownload = false) { |
acdb9177 PS |
668 | global $CFG; |
669 | ||
7dff555f | 670 | $params = array(); |
7dff555f PS |
671 | if ($forcedownload) { |
672 | $params['forcedownload'] = 1; | |
673 | } | |
acdb9177 | 674 | |
4e40406d PS |
675 | $url = new moodle_url($urlbase, $params); |
676 | $url->set_slashargument($path); | |
677 | ||
678 | return $url; | |
7dff555f PS |
679 | } |
680 | ||
681 | /** | |
682 | * Factory method for creation of url pointing to plugin file. | |
683 | * Please note this method can be used only from the plugins to | |
684 | * create urls of own files, it must not be used outside of plugins! | |
685 | * @param int $contextid | |
f28ee49e | 686 | * @param string $component |
7dff555f PS |
687 | * @param string $area |
688 | * @param int $itemid | |
689 | * @param string $pathname | |
690 | * @param string $filename | |
691 | * @param bool $forcedownload | |
692 | * @return moodle_url | |
693 | */ | |
f28ee49e | 694 | public static function make_pluginfile_url($contextid, $component, $area, $itemid, $pathname, $filename, $forcedownload = false) { |
7dff555f PS |
695 | global $CFG; |
696 | $urlbase = "$CFG->httpswwwroot/pluginfile.php"; | |
f28ee49e PS |
697 | if ($itemid === NULL) { |
698 | return self::make_file_url($urlbase, "/$contextid/$component/$area".$pathname.$filename, $forcedownload); | |
699 | } else { | |
700 | return self::make_file_url($urlbase, "/$contextid/$component/$area/$itemid".$pathname.$filename, $forcedownload); | |
701 | } | |
7dff555f PS |
702 | } |
703 | ||
704 | /** | |
705 | * Factory method for creation of url pointing to draft | |
706 | * file of current user. | |
37416d5d | 707 | * @param int $draftid draft item id |
7dff555f PS |
708 | * @param string $pathname |
709 | * @param string $filename | |
710 | * @param bool $forcedownload | |
711 | * @return moodle_url | |
712 | */ | |
37416d5d | 713 | public static function make_draftfile_url($draftid, $pathname, $filename, $forcedownload = false) { |
7dff555f PS |
714 | global $CFG, $USER; |
715 | $urlbase = "$CFG->httpswwwroot/draftfile.php"; | |
b0c6dc1c | 716 | $context = context_user::instance($USER->id); |
7dff555f | 717 | |
37416d5d | 718 | return self::make_file_url($urlbase, "/$context->id/user/draft/$draftid".$pathname.$filename, $forcedownload); |
7dff555f | 719 | } |
ed77a56f PS |
720 | |
721 | /** | |
722 | * Factory method for creating of links to legacy | |
723 | * course files. | |
724 | * @param int $courseid | |
725 | * @param string $filepath | |
726 | * @param bool $forcedownload | |
727 | * @return moodle_url | |
728 | */ | |
f28ee49e | 729 | public static function make_legacyfile_url($courseid, $filepath, $forcedownload = false) { |
ed77a56f PS |
730 | global $CFG; |
731 | ||
acdb9177 PS |
732 | $urlbase = "$CFG->wwwroot/file.php"; |
733 | return self::make_file_url($urlbase, '/'.$courseid.'/'.$filepath, $forcedownload); | |
ed77a56f | 734 | } |
48ddc9bf DP |
735 | |
736 | /** | |
737 | * Returns URL a relative path from $CFG->wwwroot | |
738 | * | |
739 | * Can be used for passing around urls with the wwwroot stripped | |
740 | * | |
741 | * @param boolean $escaped Use & as params separator instead of plain & | |
742 | * @param array $overrideparams params to add to the output url, these override existing ones with the same name. | |
743 | * @return string Resulting URL | |
744 | * @throws coding_exception if called on a non-local url | |
745 | */ | |
746 | public function out_as_local_url($escaped = true, array $overrideparams = null) { | |
747 | global $CFG; | |
748 | ||
749 | $url = $this->out($escaped, $overrideparams); | |
750 | ||
751 | if (strpos($url, $CFG->wwwroot) !== 0) { | |
752 | throw new coding_exception('out_as_local_url called on a non-local URL'); | |
753 | } | |
754 | ||
755 | return str_replace($CFG->wwwroot, '', $url); | |
756 | } | |
ffe4de97 | 757 | |
758 | /** | |
759 | * Returns the 'path' portion of a URL. For example, if the URL is | |
760 | * http://www.example.org:447/my/file/is/here.txt?really=1 then this will | |
761 | * return '/my/file/is/here.txt'. | |
762 | * | |
763 | * By default the path includes slash-arguments (for example, | |
764 | * '/myfile.php/extra/arguments') so it is what you would expect from a | |
765 | * URL path. If you don't want this behaviour, you can opt to exclude the | |
a3c17aed | 766 | * slash arguments. (Be careful: if the $CFG variable slasharguments is |
767 | * disabled, these URLs will have a different format and you may need to | |
768 | * look at the 'file' parameter too.) | |
ffe4de97 | 769 | * |
770 | * @param bool $includeslashargument If true, includes slash arguments | |
771 | * @return string Path of URL | |
772 | */ | |
773 | public function get_path($includeslashargument = true) { | |
774 | return $this->path . ($includeslashargument ? $this->slashargument : ''); | |
775 | } | |
a3c17aed | 776 | |
777 | /** | |
778 | * Returns a given parameter value from the URL. | |
779 | * | |
780 | * @param string $name Name of parameter | |
781 | * @return string Value of parameter or null if not set | |
782 | */ | |
783 | public function get_param($name) { | |
784 | if (array_key_exists($name, $this->params)) { | |
785 | return $this->params[$name]; | |
786 | } else { | |
787 | return null; | |
788 | } | |
789 | } | |
360e503e | 790 | } |
791 | ||
7cf1c7bd | 792 | /** |
793 | * Determine if there is data waiting to be processed from a form | |
794 | * | |
795 | * Used on most forms in Moodle to check for data | |
796 | * Returns the data as an object, if it's found. | |
797 | * This object can be used in foreach loops without | |
798 | * casting because it's cast to (array) automatically | |
772e78be | 799 | * |
9c0f063b | 800 | * Checks that submitted POST data exists and returns it as object. |
d48b00b4 | 801 | * |
449611af | 802 | * @uses $_POST |
9c0f063b | 803 | * @return mixed false or object |
7cf1c7bd | 804 | */ |
294ce987 | 805 | function data_submitted() { |
d48b00b4 | 806 | |
607809b3 | 807 | if (empty($_POST)) { |
36b4f985 | 808 | return false; |
809 | } else { | |
78fcdb5f | 810 | return (object)fix_utf8($_POST); |
36b4f985 | 811 | } |
812 | } | |
813 | ||
7cf1c7bd | 814 | /** |
d48b00b4 | 815 | * Given some normal text this function will break up any |
816 | * long words to a given size by inserting the given character | |
817 | * | |
6aaa17c7 | 818 | * It's multibyte savvy and doesn't change anything inside html tags. |
819 | * | |
7cf1c7bd | 820 | * @param string $string the string to be modified |
89dcb99d | 821 | * @param int $maxsize maximum length of the string to be returned |
7cf1c7bd | 822 | * @param string $cutchar the string used to represent word breaks |
823 | * @return string | |
824 | */ | |
4a5644e5 | 825 | function break_up_long_words($string, $maxsize=20, $cutchar=' ') { |
a2b3f884 | 826 | |
6aaa17c7 | 827 | /// First of all, save all the tags inside the text to skip them |
828 | $tags = array(); | |
829 | filter_save_tags($string,$tags); | |
5b07d990 | 830 | |
6aaa17c7 | 831 | /// Process the string adding the cut when necessary |
4a5644e5 | 832 | $output = ''; |
f8311def | 833 | $length = textlib::strlen($string); |
4a5644e5 | 834 | $wordlength = 0; |
835 | ||
836 | for ($i=0; $i<$length; $i++) { | |
f8311def | 837 | $char = textlib::substr($string, $i, 1); |
6aaa17c7 | 838 | if ($char == ' ' or $char == "\t" or $char == "\n" or $char == "\r" or $char == "<" or $char == ">") { |
4a5644e5 | 839 | $wordlength = 0; |
840 | } else { | |
841 | $wordlength++; | |
842 | if ($wordlength > $maxsize) { | |
843 | $output .= $cutchar; | |
844 | $wordlength = 0; | |
845 | } | |
846 | } | |
847 | $output .= $char; | |
848 | } | |
6aaa17c7 | 849 | |
850 | /// Finally load the tags back again | |
851 | if (!empty($tags)) { | |
852 | $output = str_replace(array_keys($tags), $tags, $output); | |
853 | } | |
854 | ||
4a5644e5 | 855 | return $output; |
856 | } | |
857 | ||
de6d81e6 | 858 | /** |
b166403f | 859 | * Try and close the current window using JavaScript, either immediately, or after a delay. |
449611af | 860 | * |
861 | * Echo's out the resulting XHTML & javascript | |
862 | * | |
863 | * @global object | |
864 | * @global object | |
b166403f | 865 | * @param integer $delay a delay in seconds before closing the window. Default 0. |
866 | * @param boolean $reloadopener if true, we will see if this window was a pop-up, and try | |
867 | * to reload the parent window before this one closes. | |
08396bb2 | 868 | */ |
b166403f | 869 | function close_window($delay = 0, $reloadopener = false) { |
f6794ace | 870 | global $PAGE, $OUTPUT; |
08396bb2 | 871 | |
c13a5e71 | 872 | if (!$PAGE->headerprinted) { |
de6d81e6 | 873 | $PAGE->set_title(get_string('closewindow')); |
874 | echo $OUTPUT->header(); | |
b166403f | 875 | } else { |
f6794ace | 876 | $OUTPUT->container_end_all(false); |
b166403f | 877 | } |
878 | ||
879 | if ($reloadopener) { | |
87113602 TH |
880 | // Trigger the reload immediately, even if the reload is after a delay. |
881 | $PAGE->requires->js_function_call('window.opener.location.reload', array(true)); | |
b166403f | 882 | } |
87113602 | 883 | $OUTPUT->notification(get_string('windowclosing'), 'notifysuccess'); |
cf615522 | 884 | |
87113602 | 885 | $PAGE->requires->js_function_call('close_window', array(new stdClass()), false, $delay); |
b166403f | 886 | |
7e0d6675 | 887 | echo $OUTPUT->footer(); |
b166403f | 888 | exit; |
889 | } | |
08396bb2 | 890 | |
28fbce88 | 891 | /** |
892 | * Returns a string containing a link to the user documentation for the current | |
893 | * page. Also contains an icon by default. Shown to teachers and admin only. | |
894 | * | |
895 | * @global object | |
896 | * @global object | |
897 | * @param string $text The text to be displayed for the link | |
898 | * @param string $iconpath The path to the icon to be displayed | |
899 | * @return string The link to user documentation for this current page | |
900 | */ | |
8ae8bf8a | 901 | function page_doc_link($text='') { |
28fbce88 | 902 | global $CFG, $PAGE, $OUTPUT; |
903 | ||
904 | if (empty($CFG->docroot) || during_initial_install()) { | |
905 | return ''; | |
906 | } | |
907 | if (!has_capability('moodle/site:doclinks', $PAGE->context)) { | |
908 | return ''; | |
909 | } | |
910 | ||
911 | $path = $PAGE->docspath; | |
912 | if (!$path) { | |
913 | return ''; | |
914 | } | |
8ae8bf8a | 915 | return $OUTPUT->doc_link($path, $text); |
28fbce88 | 916 | } |
917 | ||
14040797 | 918 | |
d48b00b4 | 919 | /** |
920 | * Validates an email to make sure it makes sense. | |
921 | * | |
922 | * @param string $address The email address to validate. | |
923 | * @return boolean | |
924 | */ | |
89dcb99d | 925 | function validate_email($address) { |
d48b00b4 | 926 | |
69593309 AD |
927 | return (preg_match('#^[-!\#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+'. |
928 | '(\.[-!\#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+)*'. | |
f9903ed0 | 929 | '@'. |
69593309 AD |
930 | '[-!\#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.'. |
931 | '[-!\#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$#', | |
f9903ed0 | 932 | $address)); |
933 | } | |
934 | ||
690f358b | 935 | /** |
936 | * Extracts file argument either from file parameter or PATH_INFO | |
11e7b506 | 937 | * Note: $scriptname parameter is not needed anymore |
690f358b | 938 | * |
449611af | 939 | * @global string |
940 | * @uses $_SERVER | |
941 | * @uses PARAM_PATH | |
690f358b | 942 | * @return string file path (only safe characters) |
943 | */ | |
11e7b506 | 944 | function get_file_argument() { |
945 | global $SCRIPT; | |
690f358b | 946 | |
690f358b | 947 | $relativepath = optional_param('file', FALSE, PARAM_PATH); |
948 | ||
c281862a PS |
949 | if ($relativepath !== false and $relativepath !== '') { |
950 | return $relativepath; | |
951 | } | |
952 | $relativepath = false; | |
953 | ||
954 | // then try extract file from the slasharguments | |
955 | if (stripos($_SERVER['SERVER_SOFTWARE'], 'iis') !== false) { | |
956 | // NOTE: ISS tends to convert all file paths to single byte DOS encoding, | |
957 | // we can not use other methods because they break unicode chars, | |
958 | // the only way is to use URL rewriting | |
959 | if (isset($_SERVER['PATH_INFO']) and $_SERVER['PATH_INFO'] !== '') { | |
960 | // check that PATH_INFO works == must not contain the script name | |
961 | if (strpos($_SERVER['PATH_INFO'], $SCRIPT) === false) { | |
962 | $relativepath = clean_param(urldecode($_SERVER['PATH_INFO']), PARAM_PATH); | |
963 | } | |
964 | } | |
965 | } else { | |
966 | // all other apache-like servers depend on PATH_INFO | |
967 | if (isset($_SERVER['PATH_INFO'])) { | |
968 | if (isset($_SERVER['SCRIPT_NAME']) and strpos($_SERVER['PATH_INFO'], $_SERVER['SCRIPT_NAME']) === 0) { | |
969 | $relativepath = substr($_SERVER['PATH_INFO'], strlen($_SERVER['SCRIPT_NAME'])); | |
970 | } else { | |
971 | $relativepath = $_SERVER['PATH_INFO']; | |
972 | } | |
973 | $relativepath = clean_param($relativepath, PARAM_PATH); | |
690f358b | 974 | } |
975 | } | |
976 | ||
690f358b | 977 | |
978 | return $relativepath; | |
979 | } | |
980 | ||
d48b00b4 | 981 | /** |
89dcb99d | 982 | * Just returns an array of text formats suitable for a popup menu |
d48b00b4 | 983 | * |
89dcb99d | 984 | * @uses FORMAT_MOODLE |
985 | * @uses FORMAT_HTML | |
986 | * @uses FORMAT_PLAIN | |
89dcb99d | 987 | * @uses FORMAT_MARKDOWN |
988 | * @return array | |
d48b00b4 | 989 | */ |
0095d5cd | 990 | function format_text_menu() { |
b0ccd3fb | 991 | return array (FORMAT_MOODLE => get_string('formattext'), |
992 | FORMAT_HTML => get_string('formathtml'), | |
993 | FORMAT_PLAIN => get_string('formatplain'), | |
b0ccd3fb | 994 | FORMAT_MARKDOWN => get_string('formatmarkdown')); |
0095d5cd | 995 | } |
996 | ||
d48b00b4 | 997 | /** |
998 | * Given text in a variety of format codings, this function returns | |
772e78be | 999 | * the text as safe HTML. |
d48b00b4 | 1000 | * |
c5659019 | 1001 | * This function should mainly be used for long strings like posts, |
e8276c10 | 1002 | * answers, glossary items etc. For short strings @see format_string(). |
1003 | * | |
367a75fa SH |
1004 | * <pre> |
1005 | * Options: | |
1006 | * trusted : If true the string won't be cleaned. Default false required noclean=true. | |
1007 | * noclean : If true the string won't be cleaned. Default false required trusted=true. | |
1008 | * nocache : If true the strign will not be cached and will be formatted every call. Default false. | |
1009 | * filter : If true the string will be run through applicable filters as well. Default true. | |
1010 | * para : If true then the returned string will be wrapped in div tags. Default true. | |
1011 | * newlines : If true then lines newline breaks will be converted to HTML newline breaks. Default true. | |
1012 | * context : The context that will be used for filtering. | |
1013 | * overflowdiv : If set to true the formatted text will be encased in a div | |
1014 | * with the class no-overflow before being returned. Default false. | |
b031caf8 | 1015 | * allowid : If true then id attributes will not be removed, even when |
1016 | * using htmlpurifier. Default false. | |
367a75fa SH |
1017 | * </pre> |
1018 | * | |
449611af | 1019 | * @todo Finish documenting this function |
1020 | * | |
449611af | 1021 | * @staticvar array $croncache |
89dcb99d | 1022 | * @param string $text The text to be formatted. This is raw text originally from user input. |
772e78be | 1023 | * @param int $format Identifier of the text format to be used |
35716b86 PS |
1024 | * [FORMAT_MOODLE, FORMAT_HTML, FORMAT_PLAIN, FORMAT_MARKDOWN] |
1025 | * @param object/array $options text formatting options | |
1026 | * @param int $courseid_do_not_use deprecated course id, use context option instead | |
89dcb99d | 1027 | * @return string |
d48b00b4 | 1028 | */ |
35716b86 | 1029 | function format_text($text, $format = FORMAT_MOODLE, $options = NULL, $courseid_do_not_use = NULL) { |
e3e40b43 | 1030 | global $CFG, $COURSE, $DB, $PAGE; |
1cc54a45 | 1031 | static $croncache = array(); |
795a08ad | 1032 | |
6e571603 | 1033 | if ($text === '' || is_null($text)) { |
d53ca6ad | 1034 | return ''; // no need to do any filters and cleaning |
1035 | } | |
1bcb7eb5 | 1036 | |
35716b86 | 1037 | $options = (array)$options; // detach object, we can not modify it |
d53ca6ad | 1038 | |
35716b86 PS |
1039 | if (!isset($options['trusted'])) { |
1040 | $options['trusted'] = false; | |
7d8a3cb0 | 1041 | } |
35716b86 PS |
1042 | if (!isset($options['noclean'])) { |
1043 | if ($options['trusted'] and trusttext_active()) { | |
cbc2b5df | 1044 | // no cleaning if text trusted and noclean not specified |
35716b86 | 1045 | $options['noclean'] = true; |
cbc2b5df | 1046 | } else { |
35716b86 | 1047 | $options['noclean'] = false; |
cbc2b5df | 1048 | } |
e7a47153 | 1049 | } |
35716b86 PS |
1050 | if (!isset($options['nocache'])) { |
1051 | $options['nocache'] = false; | |
a17c57b5 | 1052 | } |
35716b86 PS |
1053 | if (!isset($options['filter'])) { |
1054 | $options['filter'] = true; | |
e7a47153 | 1055 | } |
35716b86 PS |
1056 | if (!isset($options['para'])) { |
1057 | $options['para'] = true; | |
e7a47153 | 1058 | } |
35716b86 PS |
1059 | if (!isset($options['newlines'])) { |
1060 | $options['newlines'] = true; | |
f0aa2fed | 1061 | } |
367a75fa SH |
1062 | if (!isset($options['overflowdiv'])) { |
1063 | $options['overflowdiv'] = false; | |
1064 | } | |
35716b86 PS |
1065 | |
1066 | // Calculate best context | |
8d39cbb3 PS |
1067 | if (empty($CFG->version) or $CFG->version < 2010072800 or during_initial_install()) { |
1068 | // do not filter anything during installation or before upgrade completes | |
1069 | $context = null; | |
8d39cbb3 PS |
1070 | |
1071 | } else if (isset($options['context'])) { // first by explicit passed context option | |
35716b86 PS |
1072 | if (is_object($options['context'])) { |
1073 | $context = $options['context']; | |
1074 | } else { | |
fcd2cbaf | 1075 | $context = get_context_instance_by_id($options['context']); |
35716b86 PS |
1076 | } |
1077 | } else if ($courseid_do_not_use) { | |
1078 | // legacy courseid | |
b0c6dc1c | 1079 | $context = context_course::instance($courseid_do_not_use); |
35716b86 PS |
1080 | } else { |
1081 | // fallback to $PAGE->context this may be problematic in CLI and other non-standard pages :-( | |
1082 | $context = $PAGE->context; | |
c4ae4fa1 | 1083 | } |
a751a4e5 | 1084 | |
f22b7397 PS |
1085 | if (!$context) { |
1086 | // either install/upgrade or something has gone really wrong because context does not exist (yet?) | |
1087 | $options['nocache'] = true; | |
1088 | $options['filter'] = false; | |
1089 | } | |
1090 | ||
35716b86 | 1091 | if ($options['filter']) { |
ccc161f8 | 1092 | $filtermanager = filter_manager::instance(); |
6c5dbbb3 | 1093 | $filtermanager->setup_page_for_filters($PAGE, $context); // Setup global stuff filters may have. |
ccc161f8 | 1094 | } else { |
1095 | $filtermanager = new null_filter_manager(); | |
9e3f34d1 | 1096 | } |
ccc161f8 | 1097 | |
35716b86 PS |
1098 | if (!empty($CFG->cachetext) and empty($options['nocache'])) { |
1099 | $hashstr = $text.'-'.$filtermanager->text_filtering_hash($context).'-'.$context->id.'-'.current_language().'-'. | |
84a8bedd | 1100 | (int)$format.(int)$options['trusted'].(int)$options['noclean']. |
35716b86 | 1101 | (int)$options['para'].(int)$options['newlines']; |
1cc54a45 | 1102 | |
9e3f34d1 | 1103 | $time = time() - $CFG->cachetext; |
795a08ad | 1104 | $md5key = md5($hashstr); |
a91b910e | 1105 | if (CLI_SCRIPT) { |
1cc54a45 | 1106 | if (isset($croncache[$md5key])) { |
35716b86 | 1107 | return $croncache[$md5key]; |
1cc54a45 | 1108 | } |
1109 | } | |
1110 | ||
6c7f5374 | 1111 | if ($oldcacheitem = $DB->get_record('cache_text', array('md5key'=>$md5key), '*', IGNORE_MULTIPLE)) { |
a9743837 | 1112 | if ($oldcacheitem->timemodified >= $time) { |
a91b910e | 1113 | if (CLI_SCRIPT) { |
1cc54a45 | 1114 | if (count($croncache) > 150) { |
5087c945 | 1115 | reset($croncache); |
1116 | $key = key($croncache); | |
1117 | unset($croncache[$key]); | |
1cc54a45 | 1118 | } |
1119 | $croncache[$md5key] = $oldcacheitem->formattedtext; | |
1120 | } | |
35716b86 | 1121 | return $oldcacheitem->formattedtext; |
a9743837 | 1122 | } |
e7a47153 | 1123 | } |
1124 | } | |
1125 | ||
0095d5cd | 1126 | switch ($format) { |
73f8658c | 1127 | case FORMAT_HTML: |
35716b86 | 1128 | if (!$options['noclean']) { |
b031caf8 | 1129 | $text = clean_text($text, FORMAT_HTML, $options); |
9d40806d | 1130 | } |
fcd2cbaf | 1131 | $text = $filtermanager->filter_text($text, $context, array('originalformat' => FORMAT_HTML, 'noclean' => $options['noclean'])); |
73f8658c | 1132 | break; |
1133 | ||
6901fa79 | 1134 | case FORMAT_PLAIN: |
5c6347ce | 1135 | $text = s($text); // cleans dangerous JS |
ab892a4f | 1136 | $text = rebuildnolinktag($text); |
b0ccd3fb | 1137 | $text = str_replace(' ', ' ', $text); |
6901fa79 | 1138 | $text = nl2br($text); |
6901fa79 | 1139 | break; |
1140 | ||
d342c763 | 1141 | case FORMAT_WIKI: |
6a6495ff | 1142 | // this format is deprecated |
572fe9ab | 1143 | $text = '<p>NOTICE: Wiki-like formatting has been removed from Moodle. You should not be seeing |
1144 | this message as all texts should have been converted to Markdown format instead. | |
ce50cc70 | 1145 | Please post a bug report to http://moodle.org/bugs with information about where you |
e7a47153 | 1146 | saw this message.</p>'.s($text); |
d342c763 | 1147 | break; |
1148 | ||
e7cdcd18 | 1149 | case FORMAT_MARKDOWN: |
1150 | $text = markdown_to_html($text); | |
35716b86 | 1151 | if (!$options['noclean']) { |
b031caf8 | 1152 | $text = clean_text($text, FORMAT_HTML, $options); |
9d40806d | 1153 | } |
fcd2cbaf | 1154 | $text = $filtermanager->filter_text($text, $context, array('originalformat' => FORMAT_MARKDOWN, 'noclean' => $options['noclean'])); |
e7cdcd18 | 1155 | break; |
1156 | ||
73f8658c | 1157 | default: // FORMAT_MOODLE or anything else |
84a8bedd | 1158 | $text = text_to_html($text, null, $options['para'], $options['newlines']); |
35716b86 | 1159 | if (!$options['noclean']) { |
b031caf8 | 1160 | $text = clean_text($text, FORMAT_HTML, $options); |
9d40806d | 1161 | } |
fcd2cbaf | 1162 | $text = $filtermanager->filter_text($text, $context, array('originalformat' => $format, 'noclean' => $options['noclean'])); |
0095d5cd | 1163 | break; |
0095d5cd | 1164 | } |
893fe4b6 PS |
1165 | if ($options['filter']) { |
1166 | // at this point there should not be any draftfile links any more, | |
1167 | // this happens when developers forget to post process the text. | |
1168 | // The only potential problem is that somebody might try to format | |
1169 | // the text before storing into database which would be itself big bug. | |
1170 | $text = str_replace("\"$CFG->httpswwwroot/draftfile.php", "\"$CFG->httpswwwroot/brokenfile.php#", $text); | |
1171 | } | |
f0aa2fed | 1172 | |
ccc161f8 | 1173 | // Warn people that we have removed this old mechanism, just in case they |
1174 | // were stupid enough to rely on it. | |
1175 | if (isset($CFG->currenttextiscacheable)) { | |
1176 | debugging('Once upon a time, Moodle had a truly evil use of global variables ' . | |
1177 | 'called $CFG->currenttextiscacheable. The good news is that this no ' . | |
1178 | 'longer exists. The bad news is that you seem to be using a filter that '. | |
1179 | 'relies on it. Please seek out and destroy that filter code.', DEBUG_DEVELOPER); | |
1180 | } | |
1181 | ||
367a75fa SH |
1182 | if (!empty($options['overflowdiv'])) { |
1183 | $text = html_writer::tag('div', $text, array('class'=>'no-overflow')); | |
1184 | } | |
1185 | ||
35716b86 | 1186 | if (empty($options['nocache']) and !empty($CFG->cachetext)) { |
a91b910e | 1187 | if (CLI_SCRIPT) { |
1cc54a45 | 1188 | // special static cron cache - no need to store it in db if its not already there |
1189 | if (count($croncache) > 150) { | |
5087c945 | 1190 | reset($croncache); |
1191 | $key = key($croncache); | |
1192 | unset($croncache[$key]); | |
1cc54a45 | 1193 | } |
1194 | $croncache[$md5key] = $text; | |
35716b86 | 1195 | return $text; |
1cc54a45 | 1196 | } |
1197 | ||
365a5941 | 1198 | $newcacheitem = new stdClass(); |
a9743837 | 1199 | $newcacheitem->md5key = $md5key; |
f33e1ed4 | 1200 | $newcacheitem->formattedtext = $text; |
a9743837 | 1201 | $newcacheitem->timemodified = time(); |
1202 | if ($oldcacheitem) { // See bug 4677 for discussion | |
1203 | $newcacheitem->id = $oldcacheitem->id; | |
f6949ddb | 1204 | try { |
1205 | $DB->update_record('cache_text', $newcacheitem); // Update existing record in the cache table | |
1206 | } catch (dml_exception $e) { | |
1207 | // It's unlikely that the cron cache cleaner could have | |
1208 | // deleted this entry in the meantime, as it allows | |
1209 | // some extra time to cover these cases. | |
1210 | } | |
a9743837 | 1211 | } else { |
f6949ddb | 1212 | try { |
1213 | $DB->insert_record('cache_text', $newcacheitem); // Insert a new record in the cache table | |
1214 | } catch (dml_exception $e) { | |
1215 | // Again, it's possible that another user has caused this | |
1216 | // record to be created already in the time that it took | |
1217 | // to traverse this function. That's OK too, as the | |
1218 | // call above handles duplicate entries, and eventually | |
1219 | // the cron cleaner will delete them. | |
1220 | } | |
a9743837 | 1221 | } |
f0aa2fed | 1222 | } |
49c8c8d2 | 1223 | |
35716b86 | 1224 | return $text; |
0095d5cd | 1225 | } |
1226 | ||
109e3cb2 | 1227 | /** |
1228 | * Resets all data related to filters, called during upgrade or when filter settings change. | |
449611af | 1229 | * |
1230 | * @global object | |
1231 | * @global object | |
109e3cb2 | 1232 | * @return void |
1233 | */ | |
1234 | function reset_text_filters_cache() { | |
8618fd2a | 1235 | global $CFG, $DB; |
109e3cb2 | 1236 | |
8618fd2a | 1237 | $DB->delete_records('cache_text'); |
365bec4c | 1238 | $purifdir = $CFG->cachedir.'/htmlpurifier'; |
109e3cb2 | 1239 | remove_dir($purifdir, true); |
1240 | } | |
473d29eb | 1241 | |
49c8c8d2 | 1242 | /** |
449611af | 1243 | * Given a simple string, this function returns the string |
1244 | * processed by enabled string filters if $CFG->filterall is enabled | |
e8276c10 | 1245 | * |
449611af | 1246 | * This function should be used to print short strings (non html) that |
1247 | * need filter processing e.g. activity titles, post subjects, | |
1248 | * glossary concepts. | |
7b2c5e72 | 1249 | * |
449611af | 1250 | * @staticvar bool $strcache |
d07f7be8 TH |
1251 | * @param string $string The string to be filtered. Should be plain text, expect |
1252 | * possibly for multilang tags. | |
449611af | 1253 | * @param boolean $striplinks To strip any link in the result text. |
1254 | Moodle 1.8 default changed from false to true! MDL-8713 | |
35716b86 | 1255 | * @param array $options options array/object or courseid |
449611af | 1256 | * @return string |
7b2c5e72 | 1257 | */ |
35716b86 | 1258 | function format_string($string, $striplinks = true, $options = NULL) { |
e3e40b43 | 1259 | global $CFG, $COURSE, $PAGE; |
38701b69 | 1260 | |
2a3affe9 | 1261 | //We'll use a in-memory cache here to speed up repeated strings |
473d29eb | 1262 | static $strcache = false; |
1263 | ||
8d39cbb3 | 1264 | if (empty($CFG->version) or $CFG->version < 2010072800 or during_initial_install()) { |
57cddf6d PS |
1265 | // do not filter anything during installation or before upgrade completes |
1266 | return $string = strip_tags($string); | |
1267 | } | |
1268 | ||
35716b86 | 1269 | if ($strcache === false or count($strcache) > 2000) { // this number might need some tuning to limit memory usage in cron |
473d29eb | 1270 | $strcache = array(); |
1271 | } | |
84e3d2cc | 1272 | |
35716b86 PS |
1273 | if (is_numeric($options)) { |
1274 | // legacy courseid usage | |
b0c6dc1c | 1275 | $options = array('context'=>context_course::instance($options)); |
35716b86 PS |
1276 | } else { |
1277 | $options = (array)$options; // detach object, we can not modify it | |
1278 | } | |
1279 | ||
1280 | if (empty($options['context'])) { | |
1281 | // fallback to $PAGE->context this may be problematic in CLI and other non-standard pages :-( | |
1282 | $options['context'] = $PAGE->context; | |
1283 | } else if (is_numeric($options['context'])) { | |
1284 | $options['context'] = get_context_instance_by_id($options['context']); | |
1285 | } | |
1286 | ||
1287 | if (!$options['context']) { | |
1288 | // we did not find any context? weird | |
57cddf6d | 1289 | return $string = strip_tags($string); |
38701b69 | 1290 | } |
1291 | ||
2a3affe9 | 1292 | //Calculate md5 |
35716b86 | 1293 | $md5 = md5($string.'<+>'.$striplinks.'<+>'.$options['context']->id.'<+>'.current_language()); |
2a3affe9 | 1294 | |
1295 | //Fetch from cache if possible | |
38701b69 | 1296 | if (isset($strcache[$md5])) { |
2a3affe9 | 1297 | return $strcache[$md5]; |
1298 | } | |
1299 | ||
dacb47c0 | 1300 | // First replace all ampersands not followed by html entity code |
6dbcacee | 1301 | // Regular expression moved to its own method for easier unit testing |
1302 | $string = replace_ampersands_not_followed_by_entity($string); | |
268ddd50 | 1303 | |
57cddf6d | 1304 | if (!empty($CFG->filterall)) { |
b4402278 | 1305 | $filtermanager = filter_manager::instance(); |
6c5dbbb3 | 1306 | $filtermanager->setup_page_for_filters($PAGE, $options['context']); // Setup global stuff filters may have. |
b9647509 | 1307 | $string = $filtermanager->filter_string($string, $options['context']); |
7b2c5e72 | 1308 | } |
84e3d2cc | 1309 | |
9fbed9c9 | 1310 | // If the site requires it, strip ALL tags from this string |
1311 | if (!empty($CFG->formatstringstriptags)) { | |
d07f7be8 | 1312 | $string = str_replace(array('<', '>'), array('<', '>'), strip_tags($string)); |
9fbed9c9 | 1313 | |
408d5327 | 1314 | } else { |
1315 | // Otherwise strip just links if that is required (default) | |
1316 | if ($striplinks) { //strip links in string | |
31c2087d | 1317 | $string = strip_links($string); |
408d5327 | 1318 | } |
1319 | $string = clean_text($string); | |
3e6691ee | 1320 | } |
1321 | ||
2a3affe9 | 1322 | //Store to cache |
1323 | $strcache[$md5] = $string; | |
84e3d2cc | 1324 | |
7b2c5e72 | 1325 | return $string; |
1326 | } | |
1327 | ||
6dbcacee | 1328 | /** |
1329 | * Given a string, performs a negative lookahead looking for any ampersand character | |
1330 | * that is not followed by a proper HTML entity. If any is found, it is replaced | |
1331 | * by &. The string is then returned. | |
1332 | * | |
1333 | * @param string $string | |
1334 | * @return string | |
1335 | */ | |
1336 | function replace_ampersands_not_followed_by_entity($string) { | |
1337 | return preg_replace("/\&(?![a-zA-Z0-9#]{1,8};)/", "&", $string); | |
1338 | } | |
1339 | ||
31c2087d | 1340 | /** |
1341 | * Given a string, replaces all <a>.*</a> by .* and returns the string. | |
49c8c8d2 | 1342 | * |
31c2087d | 1343 | * @param string $string |
1344 | * @return string | |
1345 | */ | |
1346 | function strip_links($string) { | |
1347 | return preg_replace('/(<a\s[^>]+?>)(.+?)(<\/a>)/is','$2',$string); | |
1348 | } | |
1349 | ||
1350 | /** | |
1351 | * This expression turns links into something nice in a text format. (Russell Jungwirth) | |
1352 | * | |
1353 | * @param string $string | |
1354 | * @return string | |
1355 | */ | |
1356 | function wikify_links($string) { | |
1357 | return preg_replace('~(<a [^<]*href=["|\']?([^ "\']*)["|\']?[^>]*>([^<]*)</a>)~i','$3 [ $2 ]', $string); | |
1358 | } | |
1359 | ||
d48b00b4 | 1360 | /** |
1361 | * Given text in a variety of format codings, this function returns | |
1362 | * the text as plain text suitable for plain email. | |
d48b00b4 | 1363 | * |
89dcb99d | 1364 | * @uses FORMAT_MOODLE |
1365 | * @uses FORMAT_HTML | |
1366 | * @uses FORMAT_PLAIN | |
1367 | * @uses FORMAT_WIKI | |
1368 | * @uses FORMAT_MARKDOWN | |
1369 | * @param string $text The text to be formatted. This is raw text originally from user input. | |
772e78be | 1370 | * @param int $format Identifier of the text format to be used |
449611af | 1371 | * [FORMAT_MOODLE, FORMAT_HTML, FORMAT_PLAIN, FORMAT_WIKI, FORMAT_MARKDOWN] |
89dcb99d | 1372 | * @return string |
d48b00b4 | 1373 | */ |
d342c763 | 1374 | function format_text_email($text, $format) { |
d342c763 | 1375 | |
1376 | switch ($format) { | |
1377 | ||
1378 | case FORMAT_PLAIN: | |
1379 | return $text; | |
1380 | break; | |
1381 | ||
1382 | case FORMAT_WIKI: | |
cbc5d132 | 1383 | // there should not be any of these any more! |
31c2087d | 1384 | $text = wikify_links($text); |
7c55a29b | 1385 | return strtr(strip_tags($text), array_flip(get_html_translation_table(HTML_ENTITIES))); |
d342c763 | 1386 | break; |
1387 | ||
6ff45b59 | 1388 | case FORMAT_HTML: |
1389 | return html_to_text($text); | |
1390 | break; | |
1391 | ||
e7cdcd18 | 1392 | case FORMAT_MOODLE: |
1393 | case FORMAT_MARKDOWN: | |
67ccec43 | 1394 | default: |
31c2087d | 1395 | $text = wikify_links($text); |
7c55a29b | 1396 | return strtr(strip_tags($text), array_flip(get_html_translation_table(HTML_ENTITIES))); |
d342c763 | 1397 | break; |
1398 | } | |
1399 | } | |
0095d5cd | 1400 | |
dc5c2bd9 | 1401 | /** |
1402 | * Formats activity intro text | |
449611af | 1403 | * |
1404 | * @global object | |
1405 | * @uses CONTEXT_MODULE | |
dc5c2bd9 | 1406 | * @param string $module name of module |
1407 | * @param object $activity instance of activity | |
1408 | * @param int $cmid course module id | |
43b44d5e | 1409 | * @param bool $filter filter resulting html text |
dc5c2bd9 | 1410 | * @return text |
1411 | */ | |
43b44d5e | 1412 | function format_module_intro($module, $activity, $cmid, $filter=true) { |
ac3668bf | 1413 | global $CFG; |
1414 | require_once("$CFG->libdir/filelib.php"); | |
b0c6dc1c | 1415 | $context = context_module::instance($cmid); |
367a75fa | 1416 | $options = array('noclean'=>true, 'para'=>false, 'filter'=>$filter, 'context'=>$context, 'overflowdiv'=>true); |
64f93798 | 1417 | $intro = file_rewrite_pluginfile_urls($activity->intro, 'pluginfile.php', $context->id, 'mod_'.$module, 'intro', null); |
35716b86 | 1418 | return trim(format_text($intro, $activity->introformat, $options, null)); |
dc5c2bd9 | 1419 | } |
cbdfb929 | 1420 | |
7d8a3cb0 | 1421 | /** |
cbc2b5df | 1422 | * Legacy function, used for cleaning of old forum and glossary text only. |
449611af | 1423 | * |
1424 | * @global object | |
54f53184 PS |
1425 | * @param string $text text that may contain legacy TRUSTTEXT marker |
1426 | * @return text without legacy TRUSTTEXT marker | |
7d8a3cb0 | 1427 | */ |
1428 | function trusttext_strip($text) { | |
7d8a3cb0 | 1429 | while (true) { //removing nested TRUSTTEXT |
5ce73257 | 1430 | $orig = $text; |
cbc2b5df | 1431 | $text = str_replace('#####TRUSTTEXT#####', '', $text); |
7d8a3cb0 | 1432 | if (strcmp($orig, $text) === 0) { |
1433 | return $text; | |
1434 | } | |
1435 | } | |
1436 | } | |
1437 | ||
cbc2b5df | 1438 | /** |
1439 | * Must be called before editing of all texts | |
1440 | * with trust flag. Removes all XSS nasties | |
1441 | * from texts stored in database if needed. | |
449611af | 1442 | * |
cbc2b5df | 1443 | * @param object $object data object with xxx, xxxformat and xxxtrust fields |
1444 | * @param string $field name of text field | |
1445 | * @param object $context active context | |
1446 | * @return object updated $object | |
1447 | */ | |
1448 | function trusttext_pre_edit($object, $field, $context) { | |
1449 | $trustfield = $field.'trust'; | |
49c8c8d2 | 1450 | $formatfield = $field.'format'; |
1451 | ||
cbc2b5df | 1452 | if (!$object->$trustfield or !trusttext_trusted($context)) { |
1453 | $object->$field = clean_text($object->$field, $object->$formatfield); | |
1454 | } | |
1455 | ||
1456 | return $object; | |
1457 | } | |
1458 | ||
1459 | /** | |
449611af | 1460 | * Is current user trusted to enter no dangerous XSS in this context? |
1461 | * | |
cbc2b5df | 1462 | * Please note the user must be in fact trusted everywhere on this server!! |
449611af | 1463 | * |
1464 | * @param object $context | |
cbc2b5df | 1465 | * @return bool true if user trusted |
1466 | */ | |
1467 | function trusttext_trusted($context) { | |
49c8c8d2 | 1468 | return (trusttext_active() and has_capability('moodle/site:trustcontent', $context)); |
cbc2b5df | 1469 | } |
1470 | ||
1471 | /** | |
1472 | * Is trusttext feature active? | |
449611af | 1473 | * |
cbc2b5df | 1474 | * @return bool |
1475 | */ | |
1476 | function trusttext_active() { | |
1477 | global $CFG; | |
1478 | ||
49c8c8d2 | 1479 | return !empty($CFG->enabletrusttext); |
cbc2b5df | 1480 | } |
1481 | ||
d48b00b4 | 1482 | /** |
1483 | * Given raw text (eg typed in by a user), this function cleans it up | |
4e8d084b PS |
1484 | * and removes any nasty tags that could mess up Moodle pages through XSS attacks. |
1485 | * | |
1486 | * The result must be used as a HTML text fragment, this function can not cleanup random | |
1487 | * parts of html tags such as url or src attributes. | |
d48b00b4 | 1488 | * |
e6906df2 PS |
1489 | * NOTE: the format parameter was deprecated because we can safely clean only HTML. |
1490 | * | |
89dcb99d | 1491 | * @param string $text The text to be cleaned |
4e8d084b | 1492 | * @param int|string $format deprecated parameter, should always contain FORMAT_HTML or FORMAT_MOODLE |
b031caf8 | 1493 | * @param array $options Array of options; currently only option supported is 'allowid' (if true, |
1494 | * does not remove id attributes when cleaning) | |
89dcb99d | 1495 | * @return string The cleaned up text |
d48b00b4 | 1496 | */ |
b031caf8 | 1497 | function clean_text($text, $format = FORMAT_HTML, $options = array()) { |
986f8ea2 | 1498 | $text = (string)$text; |
3fe3851d | 1499 | |
e6906df2 PS |
1500 | if ($format != FORMAT_HTML and $format != FORMAT_HTML) { |
1501 | // TODO: we need to standardise cleanup of text when loading it into editor first | |
1502 | //debugging('clean_text() is designed to work only with html'); | |
1503 | } | |
e7cdcd18 | 1504 | |
e6906df2 PS |
1505 | if ($format == FORMAT_PLAIN) { |
1506 | return $text; | |
1507 | } | |
e7cdcd18 | 1508 | |
986f8ea2 PS |
1509 | if (is_purify_html_necessary($text)) { |
1510 | $text = purify_html($text, $options); | |
1511 | } | |
7789ffbf | 1512 | |
4e8d084b PS |
1513 | // Originally we tried to neutralise some script events here, it was a wrong approach because |
1514 | // it was trivial to work around that (for example using style based XSS exploits). | |
1515 | // We must not give false sense of security here - all developers MUST understand how to use | |
1516 | // rawurlencode(), htmlentities(), htmlspecialchars(), p(), s(), moodle_url, html_writer and friends!!! | |
6901fa79 | 1517 | |
e6906df2 | 1518 | return $text; |
b7a3cf49 | 1519 | } |
f9903ed0 | 1520 | |
986f8ea2 PS |
1521 | /** |
1522 | * Is it necessary to use HTMLPurifier? | |
1523 | * @private | |
1524 | * @param string $text | |
1525 | * @return bool false means html is safe and valid, true means use HTMLPurifier | |
1526 | */ | |
1527 | function is_purify_html_necessary($text) { | |
1528 | if ($text === '') { | |
1529 | return false; | |
1530 | } | |
1531 | ||
1532 | if ($text === (string)((int)$text)) { | |
1533 | return false; | |
1534 | } | |
1535 | ||
1536 | if (strpos($text, '&') !== false or preg_match('|<[^pesb/]|', $text)) { | |
1537 | // we need to normalise entities or other tags except p, em, strong and br present | |
1538 | return true; | |
1539 | } | |
1540 | ||
1541 | $altered = htmlspecialchars($text, ENT_NOQUOTES, 'UTF-8', true); | |
1542 | if ($altered === $text) { | |
1543 | // no < > or other special chars means this must be safe | |
1544 | return false; | |
1545 | } | |
1546 | ||
1547 | // let's try to convert back some safe html tags | |
1548 | $altered = preg_replace('|<p>(.*?)</p>|m', '<p>$1</p>', $altered); | |
1549 | if ($altered === $text) { | |
1550 | return false; | |
1551 | } | |
1552 | $altered = preg_replace('|<em>([^<>]+?)</em>|m', '<em>$1</em>', $altered); | |
1553 | if ($altered === $text) { | |
1554 | return false; | |
1555 | } | |
1556 | $altered = preg_replace('|<strong>([^<>]+?)</strong>|m', '<strong>$1</strong>', $altered); | |
1557 | if ($altered === $text) { | |
1558 | return false; | |
1559 | } | |
1560 | $altered = str_replace('<br />', '<br />', $altered); | |
1561 | if ($altered === $text) { | |
1562 | return false; | |
1563 | } | |
1564 | ||
1565 | return true; | |
1566 | } | |
1567 | ||
e0ac8448 | 1568 | /** |
1569 | * KSES replacement cleaning function - uses HTML Purifier. | |
449611af | 1570 | * |
449611af | 1571 | * @param string $text The (X)HTML string to purify |
b031caf8 | 1572 | * @param array $options Array of options; currently only option supported is 'allowid' (if set, |
1573 | * does not remove id attributes when cleaning) | |
73b309e6 | 1574 | * @return string |
e0ac8448 | 1575 | */ |
b031caf8 | 1576 | function purify_html($text, $options = array()) { |
e0ac8448 | 1577 | global $CFG; |
1578 | ||
b031caf8 | 1579 | $type = !empty($options['allowid']) ? 'allowid' : 'normal'; |
1580 | static $purifiers = array(); | |
1581 | if (empty($purifiers[$type])) { | |
7df50029 PS |
1582 | |
1583 | // make sure the serializer dir exists, it should be fine if it disappears later during cache reset | |
365bec4c | 1584 | $cachedir = $CFG->cachedir.'/htmlpurifier'; |
7df50029 PS |
1585 | check_dir_exists($cachedir); |
1586 | ||
eb203ee4 | 1587 | require_once $CFG->libdir.'/htmlpurifier/HTMLPurifier.safe-includes.php'; |
590abcf8 | 1588 | require_once $CFG->libdir.'/htmlpurifier/locallib.php'; |
e0ac8448 | 1589 | $config = HTMLPurifier_Config::createDefault(); |
f71c7f00 PS |
1590 | |
1591 | $config->set('HTML.DefinitionID', 'moodlehtml'); | |
7df50029 | 1592 | $config->set('HTML.DefinitionRev', 2); |
f71c7f00 | 1593 | $config->set('Cache.SerializerPath', $cachedir); |
7df50029 | 1594 | $config->set('Cache.SerializerPermissions', $CFG->directorypermissions); |
f71c7f00 | 1595 | $config->set('Core.NormalizeNewlines', false); |
6ec450fb | 1596 | $config->set('Core.ConvertDocumentToFragment', true); |
1597 | $config->set('Core.Encoding', 'UTF-8'); | |
1598 | $config->set('HTML.Doctype', 'XHTML 1.0 Transitional'); | |
a276778a | 1599 | $config->set('URI.AllowedSchemes', array('http'=>true, 'https'=>true, 'ftp'=>true, 'irc'=>true, 'nntp'=>true, 'news'=>true, 'rtsp'=>true, 'teamspeak'=>true, 'gopher'=>true, 'mms'=>true, 'mailto'=>true)); |
6ec450fb | 1600 | $config->set('Attr.AllowedFrameTargets', array('_blank')); |
f71c7f00 | 1601 | |
cbe44fb2 PS |
1602 | if (!empty($CFG->allowobjectembed)) { |
1603 | $config->set('HTML.SafeObject', true); | |
1604 | $config->set('Output.FlashCompat', true); | |
a0f97768 | 1605 | $config->set('HTML.SafeEmbed', true); |
cbe44fb2 PS |
1606 | } |
1607 | ||
b031caf8 | 1608 | if ($type === 'allowid') { |
1609 | $config->set('Attr.EnableID', true); | |
1610 | } | |
1611 | ||
7df50029 PS |
1612 | if ($def = $config->maybeGetRawHTMLDefinition()) { |
1613 | $def->addElement('nolink', 'Block', 'Flow', array()); // skip our filters inside | |
1614 | $def->addElement('tex', 'Inline', 'Inline', array()); // tex syntax, equivalent to $$xx$$ | |
1615 | $def->addElement('algebra', 'Inline', 'Inline', array()); // algebra syntax, equivalent to @@xx@@ | |
1616 | $def->addElement('lang', 'Block', 'Flow', array(), array('lang'=>'CDATA')); // old and future style multilang - only our hacked lang attribute | |
1617 | $def->addAttribute('span', 'xxxlang', 'CDATA'); // current problematic multilang | |
1618 | } | |
f71c7f00 | 1619 | |
e0ac8448 | 1620 | $purifier = new HTMLPurifier($config); |
b031caf8 | 1621 | $purifiers[$type] = $purifier; |
1622 | } else { | |
1623 | $purifier = $purifiers[$type]; | |
e0ac8448 | 1624 | } |
f71c7f00 PS |
1625 | |
1626 | $multilang = (strpos($text, 'class="multilang"') !== false); | |
1627 | ||
1628 | if ($multilang) { | |
1629 | $text = preg_replace('/<span(\s+lang="([a-zA-Z0-9_-]+)"|\s+class="multilang"){2}\s*>/', '<span xxxlang="${2}">', $text); | |
1630 | } | |
1631 | $text = $purifier->purify($text); | |
1632 | if ($multilang) { | |
1633 | $text = preg_replace('/<span xxxlang="([a-zA-Z0-9_-]+)">/', '<span lang="${1}" class="multilang">', $text); | |
1634 | } | |
1635 | ||
1636 | return $text; | |
e0ac8448 | 1637 | } |
1638 | ||
89dcb99d | 1639 | /** |
1640 | * Given plain text, makes it into HTML as nicely as possible. | |
1641 | * May contain HTML tags already | |
1642 | * | |
84a8bedd DM |
1643 | * Do not abuse this function. It is intended as lower level formatting feature used |
1644 | * by {@see format_text()} to convert FORMAT_MOODLE to HTML. You are supposed | |
1645 | * to call format_text() in most of cases. | |
1646 | * | |
89dcb99d | 1647 | * @param string $text The string to convert. |
84a8bedd | 1648 | * @param boolean $smiley_ignored Was used to determine if smiley characters should convert to smiley images, ignored now |
b075eb8e | 1649 | * @param boolean $para If true then the returned string will be wrapped in div tags |
89dcb99d | 1650 | * @param boolean $newlines If true then lines newline breaks will be converted to HTML newline breaks. |
1651 | * @return string | |
1652 | */ | |
84a8bedd | 1653 | function text_to_html($text, $smiley_ignored=null, $para=true, $newlines=true) { |
c1d57101 | 1654 | /// Remove any whitespace that may be between HTML tags |
6dbcacee | 1655 | $text = preg_replace("~>([[:space:]]+)<~i", "><", $text); |
7b3be1b1 | 1656 | |
c1d57101 | 1657 | /// Remove any returns that precede or follow HTML tags |
6dbcacee | 1658 | $text = preg_replace("~([\n\r])<~i", " <", $text); |
1659 | $text = preg_replace("~>([\n\r])~i", "> ", $text); | |
7b3be1b1 | 1660 | |
c1d57101 | 1661 | /// Make returns into HTML newlines. |
b7a3d3b2 | 1662 | if ($newlines) { |
1663 | $text = nl2br($text); | |
1664 | } | |
f9903ed0 | 1665 | |
b075eb8e | 1666 | /// Wrap the whole thing in a div if required |
909f539d | 1667 | if ($para) { |
b075eb8e AD |
1668 | //return '<p>'.$text.'</p>'; //1.9 version |
1669 | return '<div class="text_to_html">'.$text.'</div>'; | |
909f539d | 1670 | } else { |
1671 | return $text; | |
1672 | } | |
f9903ed0 | 1673 | } |
1674 | ||
d48b00b4 | 1675 | /** |
1676 | * Given Markdown formatted text, make it into XHTML using external function | |
1677 | * | |
449611af | 1678 | * @global object |
89dcb99d | 1679 | * @param string $text The markdown formatted text to be converted. |
1680 | * @return string Converted text | |
d48b00b4 | 1681 | */ |
e7cdcd18 | 1682 | function markdown_to_html($text) { |
e7cdcd18 | 1683 | global $CFG; |
1684 | ||
a4a0c9d9 PS |
1685 | if ($text === '' or $text === NULL) { |
1686 | return $text; | |
1687 | } | |
1688 | ||
b0ccd3fb | 1689 | require_once($CFG->libdir .'/markdown.php'); |
e7cdcd18 | 1690 | |
1691 | return Markdown($text); | |
1692 | } | |
1693 | ||
d48b00b4 | 1694 | /** |
89dcb99d | 1695 | * Given HTML text, make it into plain text using external function |
d48b00b4 | 1696 | * |
d48b00b4 | 1697 | * @param string $html The text to be converted. |
a194c218 TH |
1698 | * @param integer $width Width to wrap the text at. (optional, default 75 which |
1699 | * is a good value for email. 0 means do not limit line length.) | |
dc3e95c0 TH |
1700 | * @param boolean $dolinks By default, any links in the HTML are collected, and |
1701 | * printed as a list at the end of the HTML. If you don't want that, set this | |
1702 | * argument to false. | |
a194c218 | 1703 | * @return string plain text equivalent of the HTML. |
d48b00b4 | 1704 | */ |
dc3e95c0 | 1705 | function html_to_text($html, $width = 75, $dolinks = true) { |
89dcb99d | 1706 | |
428aaa29 | 1707 | global $CFG; |
6ff45b59 | 1708 | |
b0ccd3fb | 1709 | require_once($CFG->libdir .'/html2text.php'); |
6ff45b59 | 1710 | |
dc3e95c0 | 1711 | $h2t = new html2text($html, false, $dolinks, $width); |
588acd06 | 1712 | $result = $h2t->get_text(); |
07e9a300 | 1713 | |
977b3d31 | 1714 | return $result; |
6ff45b59 | 1715 | } |
1716 | ||
d48b00b4 | 1717 | /** |
1718 | * This function will highlight search words in a given string | |
449611af | 1719 | * |
d48b00b4 | 1720 | * It cares about HTML and will not ruin links. It's best to use |
1721 | * this function after performing any conversions to HTML. | |
d48b00b4 | 1722 | * |
9289e4c9 | 1723 | * @param string $needle The search string. Syntax like "word1 +word2 -word3" is dealt with correctly. |
1724 | * @param string $haystack The string (HTML) within which to highlight the search terms. | |
1725 | * @param boolean $matchcase whether to do case-sensitive. Default case-insensitive. | |
1726 | * @param string $prefix the string to put before each search term found. | |
1727 | * @param string $suffix the string to put after each search term found. | |
1728 | * @return string The highlighted HTML. | |
d48b00b4 | 1729 | */ |
9289e4c9 | 1730 | function highlight($needle, $haystack, $matchcase = false, |
1731 | $prefix = '<span class="highlight">', $suffix = '</span>') { | |
587c7040 | 1732 | |
9289e4c9 | 1733 | /// Quick bail-out in trivial cases. |
587c7040 | 1734 | if (empty($needle) or empty($haystack)) { |
69d51d3a | 1735 | return $haystack; |
1736 | } | |
1737 | ||
9289e4c9 | 1738 | /// Break up the search term into words, discard any -words and build a regexp. |
1739 | $words = preg_split('/ +/', trim($needle)); | |
1740 | foreach ($words as $index => $word) { | |
1741 | if (strpos($word, '-') === 0) { | |
1742 | unset($words[$index]); | |
1743 | } else if (strpos($word, '+') === 0) { | |
1744 | $words[$index] = '\b' . preg_quote(ltrim($word, '+'), '/') . '\b'; // Match only as a complete word. | |
1745 | } else { | |
1746 | $words[$index] = preg_quote($word, '/'); | |
88438a58 | 1747 | } |
1748 | } | |
9289e4c9 | 1749 | $regexp = '/(' . implode('|', $words) . ')/u'; // u is do UTF-8 matching. |
1750 | if (!$matchcase) { | |
1751 | $regexp .= 'i'; | |
88438a58 | 1752 | } |
1753 | ||
9289e4c9 | 1754 | /// Another chance to bail-out if $search was only -words |
1755 | if (empty($words)) { | |
1756 | return $haystack; | |
88438a58 | 1757 | } |
88438a58 | 1758 | |
9289e4c9 | 1759 | /// Find all the HTML tags in the input, and store them in a placeholders array. |
1760 | $placeholders = array(); | |
1761 | $matches = array(); | |
1762 | preg_match_all('/<[^>]*>/', $haystack, $matches); | |
1763 | foreach (array_unique($matches[0]) as $key => $htmltag) { | |
1764 | $placeholders['<|' . $key . '|>'] = $htmltag; | |
1765 | } | |
9ccdcd97 | 1766 | |
9289e4c9 | 1767 | /// In $hastack, replace each HTML tag with the corresponding placeholder. |
1768 | $haystack = str_replace($placeholders, array_keys($placeholders), $haystack); | |
9ccdcd97 | 1769 | |
9289e4c9 | 1770 | /// In the resulting string, Do the highlighting. |
1771 | $haystack = preg_replace($regexp, $prefix . '$1' . $suffix, $haystack); | |
9ccdcd97 | 1772 | |
9289e4c9 | 1773 | /// Turn the placeholders back into HTML tags. |
1774 | $haystack = str_replace(array_keys($placeholders), $placeholders, $haystack); | |
88438a58 | 1775 | |
f60e7cfe | 1776 | return $haystack; |
88438a58 | 1777 | } |
1778 | ||
d48b00b4 | 1779 | /** |
1780 | * This function will highlight instances of $needle in $haystack | |
449611af | 1781 | * |
1782 | * It's faster that the above function {@link highlight()} and doesn't care about | |
d48b00b4 | 1783 | * HTML or anything. |
1784 | * | |
1785 | * @param string $needle The string to search for | |
1786 | * @param string $haystack The string to search for $needle in | |
449611af | 1787 | * @return string The highlighted HTML |
d48b00b4 | 1788 | */ |
88438a58 | 1789 | function highlightfast($needle, $haystack) { |
5af78ed2 | 1790 | |
587c7040 | 1791 | if (empty($needle) or empty($haystack)) { |
1792 | return $haystack; | |
1793 | } | |
1794 | ||
6f3451e5 | 1795 | $parts = explode(textlib::strtolower($needle), textlib::strtolower($haystack)); |
5af78ed2 | 1796 | |
587c7040 | 1797 | if (count($parts) === 1) { |
1798 | return $haystack; | |
1799 | } | |
1800 | ||
5af78ed2 | 1801 | $pos = 0; |
1802 | ||
1803 | foreach ($parts as $key => $part) { | |
1804 | $parts[$key] = substr($haystack, $pos, strlen($part)); | |
1805 | $pos += strlen($part); | |
1806 | ||
b0ccd3fb | 1807 | $parts[$key] .= '<span class="highlight">'.substr($haystack, $pos, strlen($needle)).'</span>'; |
5af78ed2 | 1808 | $pos += strlen($needle); |
ab9f24ad | 1809 | } |
5af78ed2 | 1810 | |
587c7040 | 1811 | return str_replace('<span class="highlight"></span>', '', join('', $parts)); |
5af78ed2 | 1812 | } |
1813 | ||
2ab4e4b8 | 1814 | /** |
1815 | * Return a string containing 'lang', xml:lang and optionally 'dir' HTML attributes. | |
1816 | * Internationalisation, for print_header and backup/restorelib. | |
449611af | 1817 | * |
1818 | * @param bool $dir Default false | |
1819 | * @return string Attributes | |
2ab4e4b8 | 1820 | */ |
1821 | function get_html_lang($dir = false) { | |
1822 | $direction = ''; | |
1823 | if ($dir) { | |
e372f4c7 | 1824 | if (right_to_left()) { |
2ab4e4b8 | 1825 | $direction = ' dir="rtl"'; |
1826 | } else { | |
1827 | $direction = ' dir="ltr"'; | |
1828 | } | |
1829 | } | |
1830 | //Accessibility: added the 'lang' attribute to $direction, used in theme <html> tag. | |
3a915b06 | 1831 | $language = str_replace('_', '-', current_language()); |
0946fff4 | 1832 | @header('Content-Language: '.$language); |
84e3d2cc | 1833 | return ($direction.' lang="'.$language.'" xml:lang="'.$language.'"'); |
2ab4e4b8 | 1834 | } |
1835 | ||
34a2777c | 1836 | |
1837 | /// STANDARD WEB PAGE PARTS /////////////////////////////////////////////////// | |
1838 | ||
5c355019 | 1839 | /** |
34a2777c | 1840 | * Send the HTTP headers that Moodle requires. |
1841 | * @param $cacheable Can this page be cached on back? | |
5c355019 | 1842 | */ |
34a2777c | 1843 | function send_headers($contenttype, $cacheable = true) { |
5c754932 PS |
1844 | global $CFG; |
1845 | ||
34a2777c | 1846 | @header('Content-Type: ' . $contenttype); |
1847 | @header('Content-Script-Type: text/javascript'); | |
1848 | @header('Content-Style-Type: text/css'); | |
f9903ed0 | 1849 | |
34a2777c | 1850 | if ($cacheable) { |
1851 | // Allow caching on "back" (but not on normal clicks) | |
1852 | @header('Cache-Control: private, pre-check=0, post-check=0, max-age=0'); | |
1853 | @header('Pragma: no-cache'); | |
1854 | @header('Expires: '); | |
1855 | } else { | |
1856 | // Do everything we can to always prevent clients and proxies caching | |
1857 | @header('Cache-Control: no-store, no-cache, must-revalidate'); | |
1858 | @header('Cache-Control: post-check=0, pre-check=0', false); | |
1859 | @header('Pragma: no-cache'); | |
1860 | @header('Expires: Mon, 20 Aug 1969 09:23:00 GMT'); | |
1861 | @header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT'); | |
1862 | } | |
1863 | @header('Accept-Ranges: none'); | |
5c754932 PS |
1864 | |
1865 | if (empty($CFG->allowframembedding)) { | |
1866 | @header('X-Frame-Options: sameorigin'); | |
1867 | } | |
34a2777c | 1868 | } |
9fa49e22 | 1869 | |
ce3735d4 | 1870 | /** |
a84dea2c | 1871 | * Return the right arrow with text ('next'), and optionally embedded in a link. |
449611af | 1872 | * |
1873 | * @global object | |
ac905235 | 1874 | * @param string $text HTML/plain text label (set to blank only for breadcrumb separator cases). |
a84dea2c | 1875 | * @param string $url An optional link to use in a surrounding HTML anchor. |
1876 | * @param bool $accesshide True if text should be hidden (for screen readers only). | |
1877 | * @param string $addclass Additional class names for the link, or the arrow character. | |
1878 | * @return string HTML string. | |
ce3735d4 | 1879 | */ |
a84dea2c | 1880 | function link_arrow_right($text, $url='', $accesshide=false, $addclass='') { |
92e01ab7 | 1881 | global $OUTPUT; //TODO: move to output renderer |
a84dea2c | 1882 | $arrowclass = 'arrow '; |
1883 | if (! $url) { | |
1884 | $arrowclass .= $addclass; | |
1885 | } | |
92e01ab7 | 1886 | $arrow = '<span class="'.$arrowclass.'">'.$OUTPUT->rarrow().'</span>'; |
a84dea2c | 1887 | $htmltext = ''; |
1888 | if ($text) { | |
388794fd | 1889 | $htmltext = '<span class="arrow_text">'.$text.'</span> '; |
a84dea2c | 1890 | if ($accesshide) { |
1d75edd0 | 1891 | $htmltext = get_accesshide($htmltext); |
a84dea2c | 1892 | } |
ce3735d4 | 1893 | } |
a84dea2c | 1894 | if ($url) { |
388794fd | 1895 | $class = 'arrow_link'; |
a84dea2c | 1896 | if ($addclass) { |
388794fd | 1897 | $class .= ' '.$addclass; |
a84dea2c | 1898 | } |
388794fd | 1899 | return '<a class="'.$class.'" href="'.$url.'" title="'.preg_replace('/<.*?>/','',$text).'">'.$htmltext.$arrow.'</a>'; |
a84dea2c | 1900 | } |
1901 | return $htmltext.$arrow; | |
ce3735d4 | 1902 | } |
1903 | ||
1904 | /** | |
a84dea2c | 1905 | * Return the left arrow with text ('previous'), and optionally embedded in a link. |
449611af | 1906 | * |
1907 | * @global object | |
ac905235 | 1908 | * @param string $text HTML/plain text label (set to blank only for breadcrumb separator cases). |
a84dea2c | 1909 | * @param string $url An optional link to use in a surrounding HTML anchor. |
1910 | * @param bool $accesshide True if text should be hidden (for screen readers only). | |
1911 | * @param string $addclass Additional class names for the link, or the arrow character. | |
1912 | * @return string HTML string. | |
ce3735d4 | 1913 | */ |
a84dea2c | 1914 | function link_arrow_left($text, $url='', $accesshide=false, $addclass='') { |
92e01ab7 | 1915 | global $OUTPUT; // TODO: move to utput renderer |
a84dea2c | 1916 | $arrowclass = 'arrow '; |
1917 | if (! $url) { | |
1918 | $arrowclass .= $addclass; | |
1919 | } | |
92e01ab7 | 1920 | $arrow = '<span class="'.$arrowclass.'">'.$OUTPUT->larrow().'</span>'; |
a84dea2c | 1921 | $htmltext = ''; |
1922 | if ($text) { | |
388794fd | 1923 | $htmltext = ' <span class="arrow_text">'.$text.'</span>'; |
a84dea2c | 1924 | if ($accesshide) { |
1d75edd0 | 1925 | $htmltext = get_accesshide($htmltext); |
a84dea2c | 1926 | } |
ce3735d4 | 1927 | } |
a84dea2c | 1928 | if ($url) { |
388794fd | 1929 | $class = 'arrow_link'; |
a84dea2c | 1930 | if ($addclass) { |
388794fd | 1931 | $class .= ' '.$addclass; |
a84dea2c | 1932 | } |
388794fd | 1933 | return '<a class="'.$class.'" href="'.$url.'" title="'.preg_replace('/<.*?>/','',$text).'">'.$arrow.$htmltext.'</a>'; |
a84dea2c | 1934 | } |
1935 | return $arrow.$htmltext; | |
1936 | } | |
1937 | ||
1d75edd0 | 1938 | /** |
1939 | * Return a HTML element with the class "accesshide", for accessibility. | |
449611af | 1940 | * Please use cautiously - where possible, text should be visible! |
1941 | * | |
1d75edd0 | 1942 | * @param string $text Plain text. |
1943 | * @param string $elem Lowercase element name, default "span". | |
1944 | * @param string $class Additional classes for the element. | |
1945 | * @param string $attrs Additional attributes string in the form, "name='value' name2='value2'" | |
1946 | * @return string HTML string. | |
1947 | */ | |
1948 | function get_accesshide($text, $elem='span', $class='', $attrs='') { | |
1949 | return "<$elem class=\"accesshide $class\" $attrs>$text</$elem>"; | |
1950 | } | |
1951 | ||
a84dea2c | 1952 | /** |
1953 | * Return the breadcrumb trail navigation separator. | |
449611af | 1954 | * |
a84dea2c | 1955 | * @return string HTML string. |
1956 | */ | |
1957 | function get_separator() { | |
1958 | //Accessibility: the 'hidden' slash is preferred for screen readers. | |
1959 | return ' '.link_arrow_right($text='/', $url='', $accesshide=true, 'sep').' '; | |
ce3735d4 | 1960 | } |
1961 | ||
512c5901 | 1962 | /** |
fa9f6bf6 | 1963 | * Print (or return) a collapsible region, that has a caption that can |
449611af | 1964 | * be clicked to expand or collapse the region. |
49c8c8d2 | 1965 | * |
fa9f6bf6 | 1966 | * If JavaScript is off, then the region will always be expanded. |
512c5901 | 1967 | * |
1968 | * @param string $contents the contents of the box. | |
1969 | * @param string $classes class names added to the div that is output. | |
1970 | * @param string $id id added to the div that is output. Must not be blank. | |
1971 | * @param string $caption text displayed at the top. Clicking on this will cause the region to expand or contract. | |
fa9f6bf6 | 1972 | * @param string $userpref the name of the user preference that stores the user's preferred default state. |
512c5901 | 1973 | * (May be blank if you do not wish the state to be persisted. |
fa9f6bf6 | 1974 | * @param boolean $default Initial collapsed state to use if the user_preference it not set. |
512c5901 | 1975 | * @param boolean $return if true, return the HTML as a string, rather than printing it. |
449611af | 1976 | * @return string|void If $return is false, returns nothing, otherwise returns a string of HTML. |
512c5901 | 1977 | */ |
f2eb5002 | 1978 | function print_collapsible_region($contents, $classes, $id, $caption, $userpref = '', $default = false, $return = false) { |
ad9ab4df | 1979 | $output = print_collapsible_region_start($classes, $id, $caption, $userpref, $default, true); |
f2eb5002 | 1980 | $output .= $contents; |
1981 | $output .= print_collapsible_region_end(true); | |
1982 | ||
1983 | if ($return) { | |
1984 | return $output; | |
1985 | } else { | |
1986 | echo $output; | |
1987 | } | |
1988 | } | |
1989 | ||
512c5901 | 1990 | /** |
fa9f6bf6 | 1991 | * Print (or return) the start of a collapsible region, that has a caption that can |
512c5901 | 1992 | * be clicked to expand or collapse the region. If JavaScript is off, then the region |
fa9f6bf6 | 1993 | * will always be expanded. |
512c5901 | 1994 | * |
1995 | * @param string $classes class names added to the div that is output. | |
1996 | * @param string $id id added to the div that is output. Must not be blank. | |
1997 | * @param string $caption text displayed at the top. Clicking on this will cause the region to expand or contract. | |
ad9ab4df | 1998 | * @param string $userpref the name of the user preference that stores the user's preferred default state. |
512c5901 | 1999 | * (May be blank if you do not wish the state to be persisted. |
fa9f6bf6 | 2000 | * @param boolean $default Initial collapsed state to use if the user_preference it not set. |
512c5901 | 2001 | * @param boolean $return if true, return the HTML as a string, rather than printing it. |
449611af | 2002 | * @return string|void if $return is false, returns nothing, otherwise returns a string of HTML. |
512c5901 | 2003 | */ |
ad9ab4df | 2004 | function print_collapsible_region_start($classes, $id, $caption, $userpref = '', $default = false, $return = false) { |
a28c9253 | 2005 | global $CFG, $PAGE, $OUTPUT; |
f2eb5002 | 2006 | |
f2eb5002 | 2007 | // Work out the initial state. |
ad9ab4df | 2008 | if (!empty($userpref) and is_string($userpref)) { |
f2eb5002 | 2009 | user_preference_allow_ajax_update($userpref, PARAM_BOOL); |
2010 | $collapsed = get_user_preferences($userpref, $default); | |
2011 | } else { | |
2012 | $collapsed = $default; | |
2013 | $userpref = false; | |
2014 | } | |
2015 | ||
67c8a3e8 | 2016 | if ($collapsed) { |
2017 | $classes .= ' collapsed'; | |
2018 | } | |
2019 | ||
f2eb5002 | 2020 | $output = ''; |
2021 | $output .= '<div id="' . $id . '" class="collapsibleregion ' . $classes . '">'; | |
67c8a3e8 | 2022 | $output .= '<div id="' . $id . '_sizer">'; |
f2eb5002 | 2023 | $output .= '<div id="' . $id . '_caption" class="collapsibleregioncaption">'; |
2024 | $output .= $caption . ' '; | |
67c8a3e8 | 2025 | $output .= '</div><div id="' . $id . '_inner" class="collapsibleregioninner">'; |
38224dcb | 2026 | $PAGE->requires->js_init_call('M.util.init_collapsible_region', array($id, $userpref, get_string('clicktohideshow'))); |
f2eb5002 | 2027 | |
2028 | if ($return) { | |
2029 | return $output; | |
2030 | } else { | |
2031 | echo $output; | |
2032 | } | |
2033 | } | |
2034 | ||
512c5901 | 2035 | /** |
2036 | * Close a region started with print_collapsible_region_start. | |
2037 | * | |
2038 | * @param boolean $return if true, return the HTML as a string, rather than printing it. | |
449611af | 2039 | * @return string|void if $return is false, returns nothing, otherwise returns a string of HTML. |
512c5901 | 2040 | */ |
f2eb5002 | 2041 | function print_collapsible_region_end($return = false) { |
904998d8 | 2042 | $output = '</div></div></div>'; |
f2eb5002 | 2043 | |
2044 | if ($return) { | |
2045 | return $output; | |
2046 | } else { | |
2047 | echo $output; | |
2048 | } | |
2049 | } | |
2050 | ||
d48b00b4 | 2051 | /** |
2052 | * Print a specified group's avatar. | |
2053 | * | |
449611af | 2054 | * @global object |
2055 | * @uses CONTEXT_COURSE | |
a8ff9488 | 2056 | * @param array|stdClass $group A single {@link group} object OR array of groups. |
ce3735d4 | 2057 | * @param int $courseid The course ID. |
2058 | * @param boolean $large Default small picture, or large. | |
2059 | * @param boolean $return If false print picture, otherwise return the output as string | |
2060 | * @param boolean $link Enclose image in a link to view specified course? | |
449611af | 2061 | * @return string|void Depending on the setting of $return |
d48b00b4 | 2062 | */ |
da4124be | 2063 | function print_group_picture($group, $courseid, $large=false, $return=false, $link=true) { |
f374fb10 | 2064 | global $CFG; |
2065 | ||
fdcd0f05 | 2066 | if (is_array($group)) { |
2067 | $output = ''; | |
2068 | foreach($group as $g) { | |
2069 | $output .= print_group_picture($g, $courseid, $large, true, $link); | |
2070 | } | |
da4124be | 2071 | if ($return) { |
fdcd0f05 | 2072 | return $output; |
2073 | } else { | |
2074 | echo $output; | |
2075 | return; | |
2076 | } | |
2077 | } | |
2078 | ||
b0c6dc1c | 2079 | $context = context_course::instance($courseid); |
97ea4833 | 2080 | |
4a9cf90e SM |
2081 | // If there is no picture, do nothing |
2082 | if (!$group->picture) { | |
2083 | return ''; | |
2084 | } | |
2085 | ||
2086 | // If picture is hidden, only show to those with course:managegroups | |
ec7a8b79 | 2087 | if ($group->hidepicture and !has_capability('moodle/course:managegroups', $context)) { |
3c0561cf | 2088 | return ''; |
2089 | } | |
c3cbfe7f | 2090 | |
ec7a8b79 | 2091 | if ($link or has_capability('moodle/site:accessallgroups', $context)) { |
a756cf1d | 2092 | $output = '<a href="'. $CFG->wwwroot .'/user/index.php?id='. $courseid .'&group='. $group->id .'">'; |
3c0561cf | 2093 | } else { |
2094 | $output = ''; | |
2095 | } | |
2096 | if ($large) { | |
b0ccd3fb | 2097 | $file = 'f1'; |
3c0561cf | 2098 | } else { |
b0ccd3fb | 2099 | $file = 'f2'; |
3c0561cf | 2100 | } |
4a9cf90e | 2101 | |
e88dd876 | 2102 | $grouppictureurl = moodle_url::make_pluginfile_url($context->id, 'group', 'icon', $group->id, '/', $file); |
4a9cf90e SM |
2103 | $output .= '<img class="grouppicture" src="'.$grouppictureurl.'"'. |
2104 | ' alt="'.s(get_string('group').' '.$group->name).'" title="'.s($group->name).'"/>'; | |
2105 | ||
ec7a8b79 | 2106 | if ($link or has_capability('moodle/site:accessallgroups', $context)) { |
b0ccd3fb | 2107 | $output .= '</a>'; |
3c0561cf | 2108 | } |
f374fb10 | 2109 | |
da4124be | 2110 | if ($return) { |
f374fb10 | 2111 | return $output; |
2112 | } else { | |
2113 | echo $output; | |
2114 | } | |
2115 | } | |
2116 | ||
9fa49e22 | 2117 | |
449611af | 2118 | /** |
2119 | * Display a recent activity note | |
49c8c8d2 | 2120 | * |
449611af | 2121 | * @uses CONTEXT_SYSTEM |
2122 | * @staticvar string $strftimerecent | |
2123 | * @param object A time object | |
2124 | * @param object A user object | |
2125 | * @param string $text Text for display for the note | |
2126 | * @param string $link The link to wrap around the text | |
2127 | * @param bool $return If set to true the HTML is returned rather than echo'd | |
2128 | * @param string $viewfullnames | |
2129 | */ | |
dd97c328 | 2130 | function print_recent_activity_note($time, $user, $text, $link, $return=false, $viewfullnames=null) { |
2131 | static $strftimerecent = null; | |
da4124be | 2132 | $output = ''; |
2133 | ||
dd97c328 | 2134 | if (is_null($viewfullnames)) { |
b0c6dc1c | 2135 | $context = context_system::instance(); |
dd97c328 | 2136 | $viewfullnames = has_capability('moodle/site:viewfullnames', $context); |
2137 | } | |
3f8a3834 | 2138 | |
dd97c328 | 2139 | if (is_null($strftimerecent)) { |
8f7dc7f1 | 2140 | $strftimerecent = get_string('strftimerecent'); |
2141 | } | |
2142 | ||
da4124be | 2143 | $output .= '<div class="head">'; |
dd97c328 | 2144 | $output .= '<div class="date">'.userdate($time, $strftimerecent).'</div>'; |
2145 | $output .= '<div class="name">'.fullname($user, $viewfullnames).'</div>'; | |
da4124be | 2146 | $output .= '</div>'; |
2147 | $output .= '<div class="info"><a href="'.$link.'">'.format_string($text,true).'</a></div>'; | |
2148 | ||
2149 | if ($return) { | |
2150 | return $output; | |
2151 | } else { | |
2152 | echo $output; | |
2153 | } | |
8f7dc7f1 | 2154 | } |
2155 | ||
f3a74e68 | 2156 | /** |
449611af | 2157 | * Returns a popup menu with course activity modules |
2158 | * | |
a2b3f884 | 2159 | * Given a course |
f3a74e68 | 2160 | * This function returns a small popup menu with all the |
2161 | * course activity modules in it, as a navigation menu | |
a2b3f884 | 2162 | * outputs a simple list structure in XHTML |
f3a74e68 | 2163 | * The data is taken from the serialised array stored in |
2164 | * the course record | |
2165 | * | |
f3a74e68 | 2166 | * @todo Finish documenting this function |
449611af | 2167 | * |
2168 | * @global object | |
2169 | * @uses CONTEXT_COURSE | |
2170 | * @param course $course A {@link $COURSE} object. | |
2171 | * @param string $sections | |
2172 | * @param string $modinfo | |
2173 | * @param string $strsection | |
2174 | * @param string $strjumpto | |
2175 | * @param int $width | |
2176 | * @param string $cmid | |
2177 | * @return string The HTML block | |
f3a74e68 | 2178 | */ |
85489a5b | 2179 | function navmenulist($course, $sections, $modinfo, $strsection, $strjumpto, $width=50, $cmid=0) { |
f3a74e68 | 2180 | |
4bc685df | 2181 | global $CFG, $OUTPUT; |
f3a74e68 | 2182 | |
f3a74e68 | 2183 | $section = -1; |
f3a74e68 | 2184 | $url = ''; |
f3a74e68 | 2185 | $menu = array(); |
dd97c328 | 2186 | $doneheading = false; |
f3a74e68 | 2187 | |
b0c6dc1c | 2188 | $coursecontext = context_course::instance($course->id); |
85489a5b | 2189 | |
36c446cb | 2190 | $menu[] = '<ul class="navmenulist"><li class="jumpto section"><span>'.$strjumpto.'</span><ul>'; |
dd97c328 | 2191 | foreach ($modinfo->cms as $mod) { |
0d8b6a69 | 2192 | if (!$mod->has_view()) { |
2193 | // Don't show modules which you can't link to! | |
f3a74e68 | 2194 | continue; |
2195 | } | |
2196 | ||
76cbde41 | 2197 | if ($mod->sectionnum > $course->numsections) { /// Don't show excess hidden sections |
f3a74e68 | 2198 | break; |
2199 | } | |
2200 | ||
dd97c328 | 2201 | if (!$mod->uservisible) { // do not icnlude empty sections at all |
2202 | continue; | |
2203 | } | |
2204 | ||
76cbde41 | 2205 | if ($mod->sectionnum >= 0 and $section != $mod->sectionnum) { |
2206 | $thissection = $sections[$mod->sectionnum]; | |
f3a74e68 | 2207 | |
5ce73257 | 2208 | if ($thissection->visible or !$course->hiddensections or |
85489a5b | 2209 | has_capability('moodle/course:viewhiddensections', $coursecontext)) { |
f3a74e68 | 2210 | $thissection->summary = strip_tags(format_string($thissection->summary,true)); |
dd97c328 | 2211 | if (!$doneheading) { |
dfe66174 | 2212 | $menu[] = '</ul></li>'; |
f3a74e68 | 2213 | } |
2214 | if ($course->format == 'weeks' or empty($thissection->summary)) { | |
76cbde41 | 2215 | $item = $strsection ." ". $mod->sectionnum; |
f3a74e68 | 2216 | } else { |
138c7678 | 2217 | if (textlib::strlen($thissection->summary) < ($width-3)) { |
b3ab80aa | 2218 | $item = $thissection->summary; |
f3a74e68 | 2219 | } else { |
138c7678 | 2220 | $item = textlib::substr($thissection->summary, 0, $width).'...'; |
f3a74e68 | 2221 | } |
2222 | } | |
36c446cb | 2223 | $menu[] = '<li class="section"><span>'.$item.'</span>'; |
f3a74e68 | 2224 | $menu[] = '<ul>'; |
2225 | $doneheading = true; | |
dd97c328 | 2226 | |
76cbde41 | 2227 | $section = $mod->sectionnum; |
dd97c328 | 2228 | } else { |
2229 | // no activities from this hidden section shown | |
2230 | continue; | |
f3a74e68 | 2231 | } |
2232 | } | |
2233 | ||
dd97c328 | 2234 | $url = $mod->modname .'/view.php?id='. $mod->id; |
9a9012dc | 2235 | $mod->name = strip_tags(format_string($mod->name ,true)); |
138c7678 PS |
2236 | if (textlib::strlen($mod->name) > ($width+5)) { |
2237 | $mod->name = textlib::substr($mod->name, 0, $width).'...'; | |
f3a74e68 | 2238 | } |
dd97c328 | 2239 | if (!$mod->visible) { |
2240 | $mod->name = '('.$mod->name.')'; | |
2241 | } | |
2242 | $class = 'activity '.$mod->modname; | |
996c1a6f | 2243 | $class .= ($cmid == $mod->id) ? ' selected' : ''; |
dd97c328 | 2244 | $menu[] = '<li class="'.$class.'">'. |
b5d0cafc | 2245 | '<img src="'.$OUTPUT->pix_url('icon', $mod->modname) . '" alt="" />'. |
dd97c328 | 2246 | '<a href="'.$CFG->wwwroot.'/mod/'.$url.'">'.$mod->name.'</a></li>'; |
f3a74e68 | 2247 | } |
dd97c328 | 2248 | |
dfe66174 | 2249 | if ($doneheading) { |
f713e270 | 2250 | $menu[] = '</ul></li>'; |
dfe66174 | 2251 | } |
143211e5 | 2252 | $menu[] = '</ul></li></ul>'; |
f3a74e68 | 2253 | |
2254 | return implode("\n", $menu); | |
2255 | } | |
2256 | ||
d48b00b4 | 2257 | /** |
2258 | * Prints a grade menu (as part of an existing form) with help | |
2259 | * Showing all possible numerical grades and scales | |
2260 | * | |
d48b00b4 | 2261 | * @todo Finish documenting this function |
f8065dd2 | 2262 | * @todo Deprecate: this is only used in a few contrib modules |
449611af | 2263 | * |
2264 | * @global object | |
2265 | * @param int $courseid The course ID | |
49c8c8d2 | 2266 | * @param string $name |
2267 | * @param string $current | |
449611af | 2268 | * @param boolean $includenograde Include those with no grades |
2269 | * @param boolean $return If set to true returns rather than echo's | |
2270 | * @return string|bool Depending on value of $return | |
d48b00b4 | 2271 | */ |
da4124be | 2272 | function print_grade_menu($courseid, $name, $current, $includenograde=true, $return=false) { |
62ca135d | 2273 | |
e63f88c9 | 2274 | global $CFG, $OUTPUT; |
62ca135d | 2275 | |
da4124be | 2276 | $output = ''; |
b0ccd3fb | 2277 | $strscale = get_string('scale'); |
2278 | $strscales = get_string('scales'); | |
62ca135d | 2279 | |
1f7deef6 | 2280 | $scales = get_scales_menu($courseid); |
62ca135d | 2281 | foreach ($scales as $i => $scalename) { |
b0ccd3fb | 2282 | $grades[-$i] = $strscale .': '. $scalename; |
62ca135d | 2283 | } |
d6bdd9d5 | 2284 | if ($includenograde) { |
b0ccd3fb | 2285 | $grades[0] = get_string('nograde'); |
d6bdd9d5 | 2286 | } |
62ca135d | 2287 | for ($i=100; $i>=1; $i--) { |
2288 | $grades[$i] = $i; | |
2289 | } | |
d776d59e | 2290 | $output .= html_writer::select($grades, $name, $current, false); |
62ca135d | 2291 | |
b5d0cafc | 2292 | $linkobject = '<span class="helplink"><img class="iconhelp" alt="'.$strscales.'" src="'.$OUTPUT->pix_url('help') . '" /></span>'; |
57cd3739 | 2293 | $link = new moodle_url('/course/scales.php', array('id'=>$courseid, 'list'=>1)); |
48561e1b | 2294 | $action = new popup_action('click', $link, 'ratingscales', array('height' => 400, 'width' => 500)); |
57cd3739 | 2295 | $output .= $OUTPUT->action_link($link, $linkobject, $action, array('title'=>$strscales)); |
da4124be | 2296 | |
2297 | if ($return) { | |
2298 | return $output; | |
2299 | } else { | |
2300 | echo $output; | |
2301 | } | |
62ca135d | 2302 | } |
2303 | ||
7cfb11db | 2304 | /** |
2305 | * Print an error to STDOUT and exit with a non-zero code. For commandline scripts. | |
2306 | * Default errorcode is 1. | |
2307 | * | |
2308 | * Very useful for perl-like error-handling: | |
73f7ad71 | 2309 | * |
7cfb11db | 2310 | * do_somethting() or mdie("Something went wrong"); |
2311 | * | |
2312 | * @param string $msg Error message | |
73f7ad71 | 2313 | * @param integer $errorcode Error code to emit |
7cfb11db | 2314 | */ |
2315 | function mdie($msg='', $errorcode=1) { | |
2316 | trigger_error($msg); | |
2317 | exit($errorcode); | |
2318 | } | |
2319 | ||
d48b00b4 | 2320 | /** |
2321 | * Print a message and exit. | |
2322 | * | |
449611af | 2323 | * @param string $message The message to print in the notice |
2324 | * @param string $link The link to use for the continue button | |
2325 | * @param object $course A course object | |
2326 | * @return void This function simply exits | |
d48b00b4 | 2327 | */ |
1ae083e4 | 2328 | function notice ($message, $link='', $course=NULL) { |
f6794ace | 2329 | global $CFG, $SITE, $COURSE, $PAGE, $OUTPUT; |
9fa49e22 | 2330 | |
d795bfdb | 2331 | $message = clean_text($message); // In case nasties are in here |
9f7f1a74 | 2332 | |
a91b910e | 2333 | if (CLI_SCRIPT) { |
258d5322 | 2334 | echo("!!$message!!\n"); |
1c39033f | 2335 | exit(1); // no success |
d795bfdb | 2336 | } |
2337 | ||
c13a5e71 | 2338 | if (!$PAGE->headerprinted) { |
d795bfdb | 2339 | //header not yet printed |
de6d81e6 | 2340 | $PAGE->set_title(get_string('notice')); |
2341 | echo $OUTPUT->header(); | |
d795bfdb | 2342 | } else { |
f6794ace | 2343 | echo $OUTPUT->container_end_all(false); |
d795bfdb | 2344 | } |
9fa49e22 | 2345 | |
ea85e1ee | 2346 | echo $OUTPUT->box($message, 'generalbox', 'notice'); |
aa9a6867 | 2347 | echo $OUTPUT->continue_button($link); |
5ce73257 | 2348 | |
7e0d6675 | 2349 | echo $OUTPUT->footer(); |
1c39033f | 2350 | exit(1); // general error code |
9fa49e22 | 2351 | } |
2352 | ||
d48b00b4 | 2353 | /** |
2354 | * Redirects the user to another page, after printing a notice | |
2355 | * | |
e8775320 | 2356 | * This function calls the OUTPUT redirect method, echo's the output |
2357 | * and then dies to ensure nothing else happens. | |
2358 | * | |
2359 | * <strong>Good practice:</strong> You should call this method before starting page | |
2360 | * output by using any of the OUTPUT methods. | |
449611af | 2361 | * |
db82872e | 2362 | * @param moodle_url|string $url A moodle_url to redirect to. Strings are not to be trusted! |
e8775320 | 2363 | * @param string $message The message to display to the user |
2364 | * @param int $delay The delay before redirecting | |
7def9d43 | 2365 | * @return void - does not return! |
d48b00b4 | 2366 | */ |
1ae083e4 | 2367 | function redirect($url, $message='', $delay=-1) { |
8449364c | 2368 | global $OUTPUT, $PAGE, $SESSION, $CFG; |
d3f9f1f8 | 2369 | |
1adaa404 PS |
2370 | if (CLI_SCRIPT or AJAX_SCRIPT) { |
2371 | // this is wrong - developers should not use redirect in these scripts, | |
2372 | // but it should not be very likely | |
2373 | throw new moodle_exception('redirecterrordetected', 'error'); | |
2374 | } | |
2375 | ||
afa7cfa8 | 2376 | // prevent debug errors - make sure context is properly initialised |
9b540305 PS |
2377 | if ($PAGE) { |
2378 | $PAGE->set_context(null); | |
f0f8f9a7 | 2379 | $PAGE->set_pagelayout('redirect'); // No header and footer needed |
9b540305 | 2380 | } |
afa7cfa8 | 2381 | |
366c7499 | 2382 | if ($url instanceof moodle_url) { |
b9bc2019 | 2383 | $url = $url->out(false); |
366c7499 | 2384 | } |
2385 | ||
afa7cfa8 PS |
2386 | $debugdisableredirect = false; |
2387 | do { | |
2388 | if (defined('DEBUGGING_PRINTED')) { | |
2389 | // some debugging already printed, no need to look more | |
2390 | $debugdisableredirect = true; | |
2391 | break; | |
2392 | } | |
2393 | ||
2394 | if (empty($CFG->debugdisplay) or empty($CFG->debug)) { | |
2395 | // no errors should be displayed | |
2396 | break; | |
2397 | } | |
2398 | ||
2399 | if (!function_exists('error_get_last') or !$lasterror = error_get_last()) { | |
2400 | break; | |
2401 | } | |
2402 | ||
2403 | if (!($lasterror['type'] & $CFG->debug)) { | |
2404 | //last error not interesting | |
2405 | break; | |
2406 | } | |
2407 | ||
2408 | // watch out here, @hidden() errors are returned from error_get_last() too | |
2409 | if (headers_sent()) { | |
2410 | //we already started printing something - that means errors likely printed | |
2411 | $debugdisableredirect = true; | |
2412 | break; | |
2413 | } | |
2414 | ||
2415 | if (ob_get_level() and ob_get_contents()) { | |
2416 | // there is something waiting to be printed, hopefully it is the errors, | |
2417 | // but it might be some error hidden by @ too - such as the timezone mess from setup.php | |
2418 | $debugdisableredirect = true; | |
2419 | break; | |
2420 | } | |
2421 | } while (false); | |
ae96b517 | 2422 | |
581e8dba PS |
2423 | // Technically, HTTP/1.1 requires Location: header to contain the absolute path. |
2424 | // (In practice browsers accept relative paths - but still, might as well do it properly.) | |
2425 | // This code turns relative into absolute. | |
2426 | if (!preg_match('|^[a-z]+:|', $url)) { | |
2427 | // Get host name http://www.wherever.com | |
2428 | $hostpart = preg_replace('|^(.*?[^:/])/.*$|', '$1', $CFG->wwwroot); | |
2429 | if (preg_match('|^/|', $url)) { | |
2430 | // URLs beginning with / are relative to web server root so we just add them in | |
2431 | $url = $hostpart.$url; | |
2432 | } else { | |
2433 | // URLs not beginning with / are relative to path of current script, so add that on. | |
2434 | $url = $hostpart.preg_replace('|\?.*$|','',me()).'/../'.$url; | |
2435 | } | |
2436 | // Replace all ..s | |
2437 | while (true) { | |
2438 | $newurl = preg_replace('|/(?!\.\.)[^/]*/\.\./|', '/', $url); | |
2439 | if ($newurl == $url) { | |
2440 | break; | |
2441 | } | |
2442 | $url = $newurl; | |
2443 | } | |
2444 | } | |
2445 | ||
2446 | // Sanitise url - we can not rely on moodle_url or our URL cleaning | |
2447 | // because they do not support all valid external URLs | |
2448 | $url = preg_replace('/[\x00-\x1F\x7F]/', '', $url); | |
2449 | $url = str_replace('"', '%22', $url); | |
2450 | $encodedurl = preg_replace("/\&(?![a-zA-Z0-9#]{1,8};)/", "&", $url); | |
2451 | $encodedurl = preg_replace('/^.*href="([^"]*)".*$/', "\\1", clean_text('<a href="'.$encodedurl.'" />', FORMAT_HTML)); | |
2452 | $url = str_replace('&', '&', $encodedurl); | |
2453 | ||
ae96b517 | 2454 | if (!empty($message)) { |
2455 | if ($delay === -1 || !is_numeric($delay)) { | |
e8775320 | 2456 | $delay = 3; |
3446daa3 | 2457 | } |
e8775320 | 2458 | $message = clean_text($message); |
2459 | } else { | |
ae96b517 | 2460 | $message = get_string('pageshouldredirect'); |
e8775320 | 2461 | $delay = 0; |
f231e867 | 2462 | } |
2deebecd | 2463 | |
e8775320 | 2464 | if (defined('MDL_PERF') || (!empty($CFG->perfdebug) and $CFG->perfdebug > 7)) { |
2465 | if (defined('MDL_PERFTOLOG') && !function_exists('register_shutdown_function')) { | |
2466 | $perf = get_performance_info(); | |
2467 | error_log("PERF: " . $perf['txt']); | |
2468 | } | |
f231e867 | 2469 | } |
3eb89b99 | 2470 | |
ae96b517 | 2471 | if ($delay == 0 && !$debugdisableredirect && !headers_sent()) { |
b399e435 PS |
2472 | // workaround for IIS bug http://support.microsoft.com/kb/q176113/ |
2473 | if (session_id()) { | |
2474 | session_get_instance()->write_close(); | |
2475 | } | |
2476 | ||
ae96b517 | 2477 | //302 might not work for POST requests, 303 is ignored by obsolete clients. |
2478 | @header($_SERVER['SERVER_PROTOCOL'] . ' 303 See Other'); | |
2479 | @header('Location: '.$url); | |
5e39d7aa | 2480 | echo bootstrap_renderer::plain_redirect_message($encodedurl); |
2481 | exit; | |
ae96b517 | 2482 | } |
b7009474 | 2483 | |
ae96b517 | 2484 | // Include a redirect message, even with a HTTP redirect, because that is recommended practice. |
f0f8f9a7 PS |
2485 | if ($PAGE) { |
2486 | $CFG->docroot = false; // to prevent the link to moodle docs from being displayed on redirect page. | |
2487 | echo $OUTPUT->redirect_message($encodedurl, $message, $delay, $debugdisableredirect); | |
2488 | exit; | |
2489 | } else { | |
2490 | echo bootstrap_renderer::early_redirect_message($encodedurl, $message, $delay); | |
2491 | exit; | |
2492 | } | |
9fa49e22 | 2493 | } |
2494 | ||
d48b00b4 | 2495 | /** |
2496 | * Given an email address, this function will return an obfuscated version of it | |
2497 | * | |
89dcb99d | 2498 | * @param string $email The email address to obfuscate |
449611af | 2499 | * @return string The obfuscated email address |
d48b00b4 | 2500 | */ |
2501 | function obfuscate_email($email) { | |
2502 | ||
43373804 | 2503 | $i = 0; |
2504 | $length = strlen($email); | |
b0ccd3fb | 2505 | $obfuscated = ''; |
43373804 | 2506 | while ($i < $length) { |
fa801e8c | 2507 | if (rand(0,2) && $email{$i}!='@') { //MDL-20619 some browsers have problems unobfuscating @ |
43373804 | 2508 | $obfuscated.='%'.dechex(ord($email{$i})); |
2509 | } else { | |
2510 | $obfuscated.=$email{$i}; | |
2511 | } | |
2512 | $i++; | |
2513 | } | |
2514 | return $obfuscated; | |
2515 | } | |
2516 | ||
d48b00b4 | 2517 | /** |
2518 | * This function takes some text and replaces about half of the characters | |
2519 | * with HTML entity equivalents. Return string is obviously longer. | |
2520 | * | |
89dcb99d | 2521 | * @param string $plaintext The text to be obfuscated |
449611af | 2522 | * @return string The obfuscated text |
d48b00b4 | 2523 | */ |
43373804 | 2524 | function obfuscate_text($plaintext) { |
772e78be | 2525 | |
43373804 | 2526 | $i=0; |
2527 | $length = strlen($plaintext); | |
b0ccd3fb | 2528 | $obfuscated=''; |
2b09e377 | 2529 | $prev_obfuscated = false; |
43373804 | 2530 | while ($i < $length) { |
2b09e377 | 2531 | $c = ord($plaintext{$i}); |
2532 | $numerical = ($c >= ord('0')) && ($c <= ord('9')); | |
2533 | if ($prev_obfuscated and $numerical ) { | |
87d32352 | 2534 | $obfuscated.='&#'.ord($plaintext{$i}).';'; |
2b09e377 | 2535 | } else if (rand(0,2)) { |
87d32352 | 2536 | $obfuscated.='&#'.ord($plaintext{$i}).';'; |
2b09e377 | 2537 | $prev_obfuscated = true; |
43373804 | 2538 | } else { |
2539 | $obfuscated.=$plaintext{$i}; | |
2b09e377 | 2540 | $prev_obfuscated = false; |
43373804 | 2541 | } |
2b09e377 | 2542 | $i++; |
43373804 | 2543 | } |
2544 | return $obfuscated; | |
2545 | } | |
2546 | ||
d48b00b4 | 2547 | /** |
89dcb99d | 2548 | * This function uses the {@link obfuscate_email()} and {@link obfuscate_text()} |
2549 | * to generate a fully obfuscated email link, ready to use. | |
d48b00b4 | 2550 | * |
89dcb99d | 2551 | * @param string $email The email address to display |
fa9f6bf6 | 2552 | * @param string $label The text to displayed as hyperlink to $email |
89dcb99d | 2553 | * @param boolean $dimmed If true then use css class 'dimmed' for hyperlink |
449611af | 2554 | * @return string The obfuscated mailto link |
d48b00b4 | 2555 | */ |
b0ccd3fb | 2556 | function obfuscate_mailto($email, $label='', $dimmed=false) { |
43373804 | 2557 | |
2558 | if (empty($label)) { | |
2559 | $label = $email; | |
2560 | } | |
cadb96f2 | 2561 | if ($dimmed) { |
2562 | $title = get_string('emaildisable'); | |
2563 | $dimmed = ' class="dimmed"'; | |
2564 | } else { | |
2565 | $title = ''; | |
2566 | $dimmed = ''; | |
2567 | } | |
ab9f24ad | 2568 | return sprintf("<a href=\"%s:%s\" $dimmed title=\"$title\">%s</a>", |
cadb96f2 | 2569 | obfuscate_text('mailto'), obfuscate_email($email), |
2570 | obfuscate_text($label)); | |
43373804 | 2571 | } |
2572 | ||
d48b00b4 | 2573 | /** |
2574 | * This function is used to rebuild the <nolink> tag because some formats (PLAIN and WIKI) | |
2575 | * will transform it to html entities | |
2576 | * | |
89dcb99d | 2577 | * @param string $text Text to search for nolink tag in |
2578 | * @return string | |
d48b00b4 | 2579 | */ |
ab892a4f | 2580 | function rebuildnolinktag($text) { |
ab9f24ad | 2581 | |
ab892a4f | 2582 | $text = preg_replace('/<(\/*nolink)>/i','<$1>',$text); |
2583 | ||
2584 | return $text; | |
2585 | } | |
2586 | ||
1695b680 | 2587 | /** |
4fe2250a | 2588 | * Prints a maintenance message from $CFG->maintenance_message or default if empty |
49c8c8d2 | 2589 | * @return void |
1695b680 | 2590 | */ |
4fe2250a | 2591 | function print_maintenance_message() { |
3c159385 | 2592 | global $CFG, $SITE, $PAGE, $OUTPUT; |
a2b3f884 | 2593 | |
ad5d5997 | 2594 | $PAGE->set_pagetype('maintenance-message'); |
78946b9b | 2595 | $PAGE->set_pagelayout('maintenance'); |
de6d81e6 | 2596 | $PAGE->set_title(strip_tags($SITE->fullname)); |
2597 | $PAGE->set_heading($SITE->fullname); | |
2598 | echo $OUTPUT->header(); | |
3c159385 | 2599 | echo $OUTPUT->heading(get_string('sitemaintenance', 'admin')); |
4fe2250a | 2600 | if (isset($CFG->maintenance_message) and !html_is_blank($CFG->maintenance_message)) { |
ea85e1ee | 2601 | echo $OUTPUT->box_start('maintenance_message generalbox boxwidthwide boxaligncenter'); |
4fe2250a | 2602 | echo $CFG->maintenance_message; |
ea85e1ee | 2603 | echo $OUTPUT->box_end(); |
4fe2250a | 2604 | } |
7e0d6675 | 2605 | echo $OUTPUT->footer(); |
4fe2250a | 2606 | die; |
1695b680 | 2607 | } |
2608 | ||
449611af | 2609 | /** |
2610 | * A class for tabs, Some code to print tabs | |
2611 | * | |
2612 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
2613 | * @package moodlecore | |
2614 | */ | |
f88ddd67 | 2615 | class tabobject { |
449611af | 2616 | /** |
2617 | * @var string | |
2618 | */ | |
f88ddd67 | 2619 | var $id; |
2620 | var $link; | |
2621 | var $text; | |
449611af | 2622 | /** |
2623 | * @var bool | |
2624 | */ | |
748e0925 | 2625 | var $linkedwhenselected; |
f88ddd67 | 2626 | |
49c8c8d2 | 2627 | /** |
449611af | 2628 | * A constructor just because I like constructors |
49c8c8d2 | 2629 | * |
449611af | 2630 | * @param string $id |
2631 | * @param string $link | |
2632 | * @param string $text | |
2633 | * @param string $title | |
2634 | * @param bool $linkedwhenselected | |
2635 | */ | |
748e0925 | 2636 | function tabobject ($id, $link='', $text='', $title='', $linkedwhenselected=false) { |
f88ddd67 | 2637 | $this->id = $id; |
2638 | $this->link = $link; | |
2639 | $this->text = $text; | |
e7cb8f3e | 2640 | $this->title = $title ? $title : $text; |
748e0925 | 2641 | $this->linkedwhenselected = $linkedwhenselected; |
f88ddd67 | 2642 | } |
f88ddd67 | 2643 | } |
2644 | ||
2645 | ||
2646 | ||
2647 | /** | |
0b4f88a6 | 2648 | * Returns a string containing a nested list, suitable for formatting into tabs with CSS. |
f88ddd67 | 2649 | * |
449611af | 2650 | * @global object |
f88ddd67 | 2651 | * @param array $tabrows An array of rows where each row is an array of tab objects |
0b4f88a6 | 2652 | * @param string $selected The id of the selected tab (whatever row it's on) |
2653 | * @param array $inactive An array of ids of inactive tabs that are not selectable. | |
2654 | * @param array $activated An array of ids of other tabs that are currently activated | |
449611af | 2655 | * @param bool $return If true output is returned rather then echo'd |
2656 | **/ | |
0b4f88a6 | 2657 | function print_tabs($tabrows, $selected=NULL, $inactive=NULL, $activated=NULL, $return=false) { |
f88ddd67 | 2658 | global $CFG; |
2659 | ||
f88ddd67 | 2660 | /// $inactive must be an array |
2661 | if (!is_array($inactive)) { | |
2662 | $inactive = array(); | |
2663 | } | |
c06c8492 | 2664 | |
0b4f88a6 | 2665 | /// $activated must be an array |
2666 | if (!is_array($activated)) { | |
2667 | $activated = array(); | |
3e8506b6 | 2668 | } |
f88ddd67 | 2669 | |
6b25a26e | 2670 | /// Convert the tab rows into a tree that's easier to process |
0b4f88a6 | 2671 | if (!$tree = convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated)) { |
6b25a26e | 2672 | return false; |
2673 | } | |
a2b3f884 | 2674 | |
6b25a26e | 2675 | /// Print out the current tree of tabs (this function is recursive) |
84e3d2cc | 2676 | |
6b25a26e | 2677 | $output = convert_tree_to_html($tree); |
2678 | ||
2679 | $output = "\n\n".'<div class="tabtree">'.$output.'</div><div class="clearer"> </div>'."\n\n"; | |
2680 | ||
2681 | /// We're done! | |
2682 | ||
2683 | if ($return) { | |
2684 | return $output; | |
2685 | } | |
2686 | echo $output; | |
2687 | } | |
031f8487 | 2688 | |
449611af | 2689 | /** |
2690 | * Converts a nested array tree into HTML ul:li [recursive] | |
2691 | * | |
2692 | * @param array $tree A tree array to convert | |
fa9f6bf6 | 2693 | * @param int $row Used in identifying the iteration level and in ul classes |
449611af | 2694 | * @return string HTML structure |
2695 | */ | |
6b25a26e | 2696 | function convert_tree_to_html($tree, $row=0) { |
a2b3f884 | 2697 | |
6b25a26e | 2698 | $str = "\n".'<ul class="tabrow'.$row.'">'."\n"; |
a2b3f884 | 2699 | |
36e8c122 | 2700 | $first = true; |
2701 | $count = count($tree); | |
2702 | ||
6b25a26e | 2703 | foreach ($tree as $tab) { |
36e8c122 | 2704 | $count--; // countdown to zero |
2705 | ||
d11a1daa | 2706 | $liclass = ''; |
2707 | ||
65c8c793 | 2708 | if ($first && ($count == 0)) { // Just one in the row |
d11a1daa | 2709 | $liclass = 'first last'; |
65c8c793 | 2710 | $first = false; |
2711 | } else if ($first) { | |
d11a1daa | 2712 | $liclass = 'first'; |
36e8c122 | 2713 | $first = false; |
2714 | } else if ($count == 0) { | |
d11a1daa | 2715 | $liclass = 'last'; |
36e8c122 | 2716 | } |
a2b3f884 | 2717 | |
d11a1daa | 2718 | if ((empty($tab->subtree)) && (!empty($tab->selected))) { |
2719 | $liclass .= (empty($liclass)) ? 'onerow' : ' onerow'; | |
6b25a26e | 2720 | } |
f88ddd67 | 2721 | |
d1731fda | 2722 | if ($tab->inactive || $tab->active || $tab->selected) { |
84e3d2cc | 2723 | if ($tab->selected) { |
d11a1daa | 2724 | $liclass .= (empty($liclass)) ? 'here selected' : ' here selected'; |
84e3d2cc | 2725 | } else if ($tab->active) { |
d11a1daa | 2726 | $liclass .= (empty($liclass)) ? 'here active' : ' here active'; |
2727 | } | |
2728 | } | |
2729 | ||
2730 | $str .= (!empty($liclass)) ? '<li class="'.$liclass.'">' : '<li>'; | |
2731 | ||
2732 | if ($tab->inactive || $tab->active || ($tab->selected && !$tab->linkedwhenselected)) { | |
ca3b6e52 | 2733 | // The a tag is used for styling |
2734 | $str .= '<a class="nolink"><span>'.$tab->text.'</span></a>'; | |
6b25a26e | 2735 | } else { |
d11a1daa | 2736 | $str .= '<a href="'.$tab->link.'" title="'.$tab->title.'"><span>'.$tab->text.'</span></a>'; |
f88ddd67 | 2737 | } |
a2b3f884 | 2738 | |
84e3d2cc | 2739 | if (!empty($tab->subtree)) { |
6b25a26e | 2740 | $str .= convert_tree_to_html($tab->subtree, $row+1); |
36e8c122 | 2741 | } else if ($tab->selected) { |
d11a1daa | 2742 | $str .= '<div class="tabrow'.($row+1).' empty"> </div>'."\n"; |
6b25a26e | 2743 | } |
2744 | ||
a04c3b55 | 2745 | $str .= ' </li>'."\n"; |
f88ddd67 | 2746 | } |
6b25a26e | 2747 | $str .= '</ul>'."\n"; |
a2b3f884 | 2748 | |
6b25a26e | 2749 | return $str; |
2750 | } | |
2751 | ||
449611af | 2752 | /** |
2753 | * Convert nested tabrows to a nested array | |
2754 | * | |
2755 | * @param array $tabrows A [nested] array of tab row objects | |
2756 | * @param string $selected The tabrow to select (by id) | |
2757 | * @param array $inactive An array of tabrow id's to make inactive | |
2758 | * @param array $activated An array of tabrow id's to make active | |
49c8c8d2 | 2759 | * @return array The nested array |
449611af | 2760 | */ |
0b4f88a6 | 2761 | function convert_tabrows_to_tree($tabrows, $selected, $inactive, $activated) { |
6b25a26e | 2762 | |
2763 | /// Work backwards through the rows (bottom to top) collecting the tree as we go. | |
2764 | ||
2765 | $tabrows = array_reverse($tabrows); | |
2766 | ||
2767 | $subtree = array(); | |
2768 | ||
2769 | foreach ($tabrows as $row) { | |
2770 | $tree = array(); | |
2771 | ||
2772 | foreach ($row as $tab) { | |
f522d310 | 2773 | $tab->inactive = in_array((string)$tab->id, $inactive); |
2774 | $tab->active = in_array((string)$tab->id, $activated); | |
2775 | $tab->selected = (string)$tab->id == $selected; | |
6b25a26e | 2776 | |
2777 | if ($tab->active || $tab->selected) { | |
2778 | if ($subtree) { | |
2779 | $tab->subtree = $subtree; | |
2780 | } | |
2781 | } | |
2782 | $tree[] = $tab; | |
2783 | } | |
2784 | $subtree = $tree; | |
027b0fe7 | 2785 | } |
6b25a26e | 2786 | |
3eb89b99 | 2787 | return $subtree; |
f88ddd67 | 2788 | } |
2789 | ||
fa989c38 | 2790 | /** |
449611af | 2791 | * Standard Debugging Function |
2792 | * | |
7eb0b60a | 2793 | * Returns true if the current site debugging settings are equal or above specified level. |
4bd0ddea | 2794 | * If passed a parameter it will emit a debugging notice similar to trigger_error(). The |
2795 | * routing of notices is controlled by $CFG->debugdisplay | |
fa989c38 | 2796 | * eg use like this: |
2797 | * | |
7eb0b60a | 2798 | * 1) debugging('a normal debug notice'); |
2799 | * 2) debugging('something really picky', DEBUG_ALL); | |
fa9f6bf6 | 2800 | * 3) debugging('annoying debug message only for developers', DEBUG_DEVELOPER); |
4bd0ddea | 2801 | * 4) if (debugging()) { perform extra debugging operations (do not use print or echo) } |
2802 | * | |
2803 | * In code blocks controlled by debugging() (such as example 4) | |
2804 | * any output should be routed via debugging() itself, or the lower-level | |
2805 | * trigger_error() or error_log(). Using echo or print will break XHTML | |
2806 | * JS and HTTP headers. | |
2807 | * | |
2e9b772f | 2808 | * It is also possible to define NO_DEBUG_DISPLAY which redirects the message to error_log. |
fa989c38 | 2809 | * |
449611af | 2810 | * @uses DEBUG_NORMAL |
2fca6e0b | 2811 | * @param string $message a message to print |
fa989c38 | 2812 | * @param int $level the level at which this debugging statement should show |
eee5d9bb | 2813 | * @param array $backtrace use different backtrace |
fa989c38 | 2814 | * @return bool |
2815 | */ | |
34a2777c | 2816 | function debugging($message = '', $level = DEBUG_NORMAL, $backtrace = null) { |
c8b3346c | 2817 | global $CFG, $USER; |
fa989c38 | 2818 | |
0ed26d12 | 2819 | $forcedebug = false; |
5dad4591 | 2820 | if (!empty($CFG->debugusers) && $USER) { |
0ed26d12 PS |
2821 | $debugusers = explode(',', $CFG->debugusers); |
2822 | $forcedebug = in_array($USER->id, $debugusers); | |
2823 | } | |
2824 | ||
a3d5830a | 2825 | if (!$forcedebug and (empty($CFG->debug) || ($CFG->debug != -1 and $CFG->debug < $level))) { |
fa989c38 | 2826 | return false; |
2827 | } | |
2828 | ||
34a2777c | 2829 | if (!isset($CFG->debugdisplay)) { |
2830 | $CFG->debugdisplay = ini_get_bool('display_errors'); | |
795a08ad | 2831 | } |
2832 | ||
34a2777c | 2833 | if ($message) { |
2834 | if (!$backtrace) { | |
2835 | $backtrace = debug_backtrace(); | |
251387d0 | 2836 | } |
34a2777c | 2837 | $from = format_backtrace($backtrace, CLI_SCRIPT); |
a3d5830a | 2838 | if (PHPUNIT_TEST) { |
5bd40408 PS |
2839 | echo 'Debugging: ' . $message . "\n" . $from; |
2840 | ||
2e9b772f PS |
2841 | } else if (NO_DEBUG_DISPLAY) { |
2842 | // script does not want any errors or debugging in output, | |
2843 | // we send the info to error log instead | |
2844 | error_log('Debugging: ' . $message . $from); | |
2845 | ||
0ed26d12 | 2846 | } else if ($forcedebug or $CFG->debugdisplay) { |
34a2777c | 2847 | if (!defined('DEBUGGING_PRINTED')) { |
2848 | define('DEBUGGING_PRINTED', 1); // indicates we have printed something | |
251387d0 | 2849 | } |
2df1126b PS |
2850 | if (CLI_SCRIPT) { |
2851 | echo "++ $message ++\n$from"; | |
2852 | } else { | |
2853 | echo '<div class="notifytiny">' . $message . $from . '</div>'; | |
2854 | } | |
2e9b772f | 2855 | |
34a2777c | 2856 | } else { |
2857 | trigger_error($message . $from, E_USER_NOTICE); | |
251387d0 | 2858 | } |
251387d0 | 2859 | } |
34a2777c | 2860 | return true; |
251387d0 | 2861 | } |
2862 | ||
4d0ccfa7 | 2863 | /** |
2864 | * Outputs a HTML comment to the browser. This is used for those hard-to-debug | |
2865 | * pages that use bits from many different files in very confusing ways (e.g. blocks). | |
449611af | 2866 | * |
2867 | * <code>print_location_comment(__FILE__, __LINE__);</code> | |
2868 | * | |
4d0ccfa7 | 2869 | * @param string $file |
2870 | * @param integer $line | |
2871 | * @param boolean $return Whether to return or print the comment | |
449611af | 2872 | * @return string|void Void unless true given as third parameter |
4d0ccfa7 | 2873 | */ |
2874 | function print_location_comment($file, $line, $return = false) | |
2875 | { | |
2876 | if ($return) { | |
2877 | return "<!-- $file at line $line -->\n"; | |
2878 | } else { | |
2879 | echo "<!-- $file at line $line -->\n"; | |
2880 | } | |
2881 | } | |
f145c248 | 2882 | |
82b4da86 | 2883 | |
f1af7aaa | 2884 | /** |
b7009474 | 2885 | * @return boolean true if the current language is right-to-left (Hebrew, Arabic etc) |
b2118095 | 2886 | */ |
2887 | function right_to_left() { | |
e372f4c7 | 2888 | return (get_string('thisdirection', 'langconfig') === 'rtl'); |
b2118095 | 2889 | } |
2890 | ||
2891 | ||
2892 | /** | |
2893 | * Returns swapped left<=>right if in RTL environment. | |
2894 | * part of RTL support | |
2895 | * | |
2896 | * @param string $align align to check | |
2897 | * @return string | |
2898 | */ | |
2899 | function fix_align_rtl($align) { | |
c5659019 | 2900 | if (!right_to_left()) { |
f1af7aaa | 2901 | return $align; |
b2118095 | 2902 | } |
c5659019 | 2903 | if ($align=='left') { return 'right'; } |
2904 | if ($align=='right') { return 'left'; } | |
2905 | return $align; | |
b2118095 | 2906 | } |
2907 | ||
2908 | ||
ee9beb53 | 2909 | /** |
2910 | * Returns true if the page is displayed in a popup window. | |
2911 | * Gets the information from the URL parameter inpopup. | |
2912 | * | |
fa9f6bf6 | 2913 | * @todo Use a central function to create the popup calls all over Moodle and |
449611af | 2914 | * In the moment only works with resources and probably questions. |
ee9beb53 | 2915 | * |
449611af | 2916 | * @return boolean |
ee9beb53 | 2917 | */ |
f7c926ee | 2918 | function is_in_popup() { |
ee9beb53 | 2919 | $inpopup = optional_param('inpopup', '', PARAM_BOOL); |
c5659019 | 2920 | |
ee9beb53 | 2921 | return ($inpopup); |
2922 | } | |
27bd819b | 2923 | |
c9ec505b | 2924 | /** |
2925 | * To use this class. | |
2926 | * - construct | |
2927 | * - call create (or use the 3rd param to the constructor) | |
dfd9f745 | 2928 | * - call update or update_full() or update() repeatedly |
449611af | 2929 | * |
2930 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
2931 | * @package moodlecore | |
c9ec505b | 2932 | */ |
a6553373 | 2933 | class progress_bar { |
fd4faf98 | 2934 | /** @var string html id */ |
a6553373 | 2935 | private $html_id; |
dfd9f745 | 2936 | /** @var int total width */ |
a6553373 | 2937 | private $width; |
dfd9f745 PS |
2938 | /** @var int last percentage printed */ |
2939 | private $percent = 0; | |
2940 | /** @var int time when last printed */ | |
2941 | private $lastupdate = 0; | |
2942 | /** @var int when did we start printing this */ | |
2943 | private $time_start = 0; | |
2944 | ||
449611af | 2945 | /** |
fa9f6bf6 | 2946 | * Constructor |
449611af | 2947 | * |
2948 | * @param string $html_id | |
2949 | * @param int $width | |
2950 | * @param bool $autostart Default to false | |
dfd9f745 | 2951 | * @return void, prints JS code if $autostart true |
449611af | 2952 | */ |
dfd9f745 | 2953 | public function __construct($html_id = '', $width = 500, $autostart = false) { |
fd4faf98 | 2954 | if (!empty($html_id)) { |
2955 | $this->html_id = $html_id; | |
2956 | } else { | |
dfd9f745 | 2957 | $this->html_id = 'pbar_'.uniqid(); |
fd4faf98 | 2958 | } |
dfd9f745 | 2959 | |
a6553373 | 2960 | $this->width = $width; |
dfd9f745 PS |
2961 | |
2962 | if ($autostart){ | |
a6553373 | 2963 | $this->create(); |
2964 | } | |
2965 | } | |
dfd9f745 | 2966 | |
a6553373 | 2967 | /** |
449611af | 2968 | * Create a new progress bar, this function will output html. |
49c8c8d2 | 2969 | * |
449611af | 2970 | * @return void Echo's output |
a6553373 | 2971 | */ |
dfd9f745 PS |
2972 | public function create() { |
2973 | $this->time_start = microtime(true); | |
2974 | if (CLI_SCRIPT) { | |
2975 | return; // temporary solution for cli scripts | |
2976 | } | |
2977 | $htmlcode = <<<EOT | |
2978 | <div style="text-align:center;width:{$this->width}px;clear:both;padding:0;margin:0 auto;"> | |
2979 | <h2 id="status_{$this->html_id}" style="text-align: center;margin:0 auto"></h2> | |
2980 | <p id="time_{$this->html_id}"></p> | |
2981 | <div id="bar_{$this->html_id}" style="border-style:solid;border-width:1px;width:500px;height:50px;"> | |
2982 | <div id="progress_{$this->html_id}" | |
2983 | style="text-align:center;background:#FFCC66;width:4px;border:1px | |
2984 | solid gray;height:38px; padding-top:10px;"> <span id="pt_{$this->html_id}"></span> | |
a6553373 | 2985 | </div> |
2986 | </div> | |
dfd9f745 | 2987 | </div> |
a6553373 | 2988 | EOT; |
dfd9f745 PS |
2989 | flush(); |
2990 | echo $htmlcode; | |
2991 | flush(); | |
a6553373 | 2992 | } |
dfd9f745 | 2993 | |
449611af | 2994 | /** |
2995 | * Update the progress bar | |
2996 | * | |
2997 | * @param int $percent from 1-100 | |
2998 | * @param string $msg | |
449611af | 2999 | * @return void Echo's output |
3000 | */ | |
dfd9f745 | 3001 | private function _update($percent, $msg) { |
6481b28f TH |
3002 | if (empty($this->time_start)) { |
3003 | throw new coding_exception('You must call create() (or use the $autostart ' . | |
3004 | 'argument to the constructor) before you try updating the progress bar.'); | |
a6553373 | 3005 | } |
dfd9f745 | 3006 | |
3316fe24 | 3007 | if (CLI_SCRIPT) { |
3008 | return; // temporary solution for cli scripts | |
3009 | } | |
dfd9f745 PS |
3010 | |
3011 | $es = $this->estimate($percent); | |
3012 | ||
3013 | if ($es === null) { | |
3014 | // always do the first and last updates | |
3015 | $es = "?"; | |
3016 | } else if ($es == 0) { | |
3017 | // always do the last updates | |
3018 | } else if ($this->lastupdate + 20 < time()) { | |
3019 | // we must update otherwise browser would time out | |
3020 | } else if (round($this->percent, 2) === round($percent, 2)) { | |
3021 | // no significant change, no need to update anything | |
3022 | return; | |
a6553373 | 3023 | } |
dfd9f745 PS |
3024 | |
3025 | $this->percent = $percent; | |
3026 | $this->lastupdate = microtime(true); | |
3027 | ||
3028 | $w = ($this->percent/100) * $this->width; | |
3029 | echo html_writer::script(js_writer::function_call('update_progress_bar', array($this->html_id, $w, $this->percent, $msg, $es))); | |
a6553373 | 3030 | flush(); |
3031 | } | |
dfd9f745 | 3032 | |
a6553373 | 3033 | /** |
dfd9f745 | 3034 | * Estimate how much time it is going to take. |
07e9a300 | 3035 | * |
449611af | 3036 | * @param int $curtime the time call this function |
3037 | * @param int $percent from 1-100 | |
dfd9f745 | 3038 | * @return mixed Null (unknown), or int |
a6553373 | 3039 | */ |
dfd9f745 PS |
3040 | private function estimate($pt) { |
3041 | if ($this->lastupdate == 0) { | |
a6553373 | 3042 | return null; |
c9ec505b | 3043 | } |
dfd9f745 PS |
3044 | if ($pt < 0.00001) { |
3045 | return null; // we do not know yet how long it will take | |
3046 | } | |
3047 | if ($pt > 99.99999) { | |
3048 | return 0; // nearly done, right? | |
c9ec505b | 3049 | } |
dfd9f745 PS |
3050 | $consumed = microtime(true) - $this->time_start; |
3051 | if ($consumed < 0.001) { | |
3052 | return null; | |
3053 | } | |
3054 | ||
3055 | return (100 - $pt) * ($consumed / $pt); | |
a6553373 | 3056 | } |
dfd9f745 | 3057 | |
a6553373 | 3058 | /** |
3059 | * Update progress bar according percent | |
07e9a300 | 3060 | * |
449611af | 3061 | * @param int $percent from 1-100 |
3062 | * @param string $msg the message needed to be shown | |
a6553373 | 3063 | */ |
dfd9f745 | 3064 | public function update_full($percent, $msg) { |
a6553373 | 3065 | $percent = max(min($percent, 100), 0); |
dfd9f745 | 3066 | $this->_update($percent, $msg); |
a6553373 | 3067 | } |
dfd9f745 | 3068 | |
a6553373 | 3069 | /** |
fa9f6bf6 | 3070 | * Update progress bar according the number of tasks |
07e9a300 | 3071 | * |
449611af | 3072 | * @param int $cur current task number |
3073 | * @param int $total total task number | |
3074 | * @param string $msg message | |
a6553373 | 3075 | */ |
dfd9f745 PS |
3076 | public function update($cur, $total, $msg) { |
3077 | $percent = ($cur / $total) * 100; | |
3078 | $this->update_full($percent, $msg); | |
a6553373 | 3079 | } |
dfd9f745 | 3080 | |
a6553373 | 3081 | /** |
3082 | * Restart the progress bar. | |
3083 | */ | |
dfd9f745 PS |
3084 | public function restart() { |
3085 | $this->percent = 0; | |
3086 | $this->lastupdate = 0; | |
3087 | $this->time_start = 0; | |
a6553373 | 3088 | } |
3089 | } | |
ee9beb53 | 3090 | |
e82e01d1 | 3091 | /** |
3092 | * Use this class from long operations where you want to output occasional information about | |
3093 | * what is going on, but don't know if, or in what format, the output should be. | |
449611af | 3094 | * |
3095 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
3096 | * @package moodlecore | |
e82e01d1 | 3097 | */ |
cb1e046d | 3098 | abstract class progress_trace { |
e82e01d1 | 3099 | /** |
3100 | * Ouput an progress message in whatever format. | |
3101 | * @param string $message the message to output. | |
3102 | * @param integer $depth indent depth for this message. | |
3103 | */ | |
3104 | abstract public function output($message, $depth = 0); | |
3105 | ||
3106 | /** | |
3107 | * Called when the processing is finished. | |
3108 | */ | |
3109 | public function finished() { | |
e82e01d1 | 3110 | } |
3111 | } | |
3112 | ||
3113 | /** | |
cb1e046d | 3114 | * This subclass of progress_trace does not ouput anything. |
449611af | 3115 | * |
3116 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
3117 | * @package moodlecore | |
e82e01d1 | 3118 | */ |
cb1e046d | 3119 | class null_progress_trace extends progress_trace { |
449611af | 3120 | /** |
3121 | * Does Nothing | |
3122 | * | |
3123 | * @param string $message | |
3124 | * @param int $depth | |
3125 | * @return void Does Nothing | |
3126 | */ | |
e82e01d1 | 3127 | public function output($message, $depth = 0) { |
3128 | } | |
3129 | } | |
3130 | ||
3131 | /** | |
cb1e046d | 3132 | * This subclass of progress_trace outputs to plain text. |
449611af | 3133 | * |
3134 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
3135 | * @package moodlecore | |
e82e01d1 | 3136 | */ |
cb1e046d | 3137 | class text_progress_trace extends progress_trace { |
449611af | 3138 | /** |
3139 | * Output the trace message | |
3140 | * | |
3141 | * @param string $message | |
3142 | * @param int $depth | |
3143 | * @return void Output is echo'd | |
3144 | */ | |
e82e01d1 | 3145 | public function output($message, $depth = 0) { |
3146 | echo str_repeat(' ', $depth), $message, "\n"; | |
3147 | flush(); | |
3148 | } | |
3149 | } | |
3150 | ||
3151 | /** | |
cb1e046d | 3152 | * This subclass of progress_trace outputs as HTML. |
449611af | 3153 | * |
3154 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
3155 | * @package moodlecore | |
e82e01d1 | 3156 | */ |
cb1e046d | 3157 | class html_progress_trace extends progress_trace { |
449611af | 3158 | /** |
3159 | * Output the trace message | |
3160 | * | |
3161 | * @param string $message | |
3162 | * @param int $depth | |
3163 | * @return void Output is echo'd | |
3164 | */ | |
e82e01d1 | 3165 | public function output($message, $depth = 0) { |
3166 | echo '<p>', str_repeat('  ', $depth), htmlspecialchars($message), "</p>\n"; | |
3167 | flush(); | |
3168 | } | |
3169 | } | |
3170 | ||
449611af | 3171 | /** |
3172 | * HTML List Progress Tree | |
3173 | * | |
3174 | * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later | |
3175 | * @package moodlecore | |
3176 | */ | |
cb1e046d | 3177 | class html_list_progress_trace extends progress_trace { |
449611af | 3178 | /** @var int */ |
e82e01d1 | 3179 | protected $currentdepth = -1; |
3180 | ||
449611af | 3181 | /** |
3182 | * Echo out the list | |
3183 | * | |
3184 | * @param string $message The message to display | |
3185 | * @param int $depth | |
3186 | * @return void Output is echoed | |
3187 | */ | |
e82e01d1 | 3188 | public function output($message, $depth = 0) { |
3189 | $samedepth = true; | |
3190 | while ($this->currentdepth > $depth) { | |
3191 | echo "</li>\n</ul>\n"; | |
3192 | $this->currentdepth -= 1; | |
3193 | if ($this->currentdepth == $depth) { | |
3194 | echo '<li>'; | |
3195 | } | |
3196 | $samedepth = false; | |
3197 | } | |
3198 | while ($this->currentdepth < $depth) { | |
3199 | echo "<ul>\n<li>"; | |
3200 | $this->currentdepth += 1; | |
3201 | $samedepth = false; | |
3202 | } | |
3203 | if ($samedepth) { | |
3204 | echo "</li>\n<li>"; | |
3205 | } | |
3206 | echo htmlspecialchars($message); | |
3207 | flush(); | |
3208 | } | |
3209 | ||
449611af | 3210 | /** |