Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
- Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
- PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
/lib/ -> formslib.php (source)
Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402] [Versions 400 and 402] [Versions 401 and 402] [Versions 402 and 403]
1 <?php 2 // This file is part of Moodle - http://moodle.org/ 3 // 4 // Moodle is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // Moodle is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with Moodle. If not, see <http://www.gnu.org/licenses/>. 16 17 /** 18 * formslib.php - library of classes for creating forms in Moodle, based on PEAR QuickForms. 19 * 20 * To use formslib then you will want to create a new file purpose_form.php eg. edit_form.php 21 * and you want to name your class something like {modulename}_{purpose}_form. Your class will 22 * extend moodleform overriding abstract classes definition and optionally defintion_after_data 23 * and validation. 24 * 25 * See examples of use of this library in course/edit.php and course/edit_form.php 26 * 27 * A few notes : 28 * form definition is used for both printing of form and processing and should be the same 29 * for both or you may lose some submitted data which won't be let through. 30 * you should be using setType for every form element except select, radio or checkbox 31 * elements, these elements clean themselves. 32 * 33 * @package core_form 34 * @copyright 2006 Jamie Pratt <me@jamiep.org> 35 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 36 */ 37 38 defined('MOODLE_INTERNAL') || die(); 39 40 /** setup.php includes our hacked pear libs first */ 41 require_once 'HTML/QuickForm.php'; 42 require_once 'HTML/QuickForm/DHTMLRulesTableless.php'; 43 require_once 'HTML/QuickForm/Renderer/Tableless.php'; 44 require_once 'HTML/QuickForm/Rule.php'; 45 46 require_once $CFG->libdir.'/filelib.php'; 47 48 /** 49 * EDITOR_UNLIMITED_FILES - hard-coded value for the 'maxfiles' option 50 */ 51 define('EDITOR_UNLIMITED_FILES', -1); 52 53 /** 54 * Callback called when PEAR throws an error 55 * 56 * @param PEAR_Error $error 57 */ 58 function pear_handle_error($error){ 59 echo '<strong>'.$error->GetMessage().'</strong> '.$error->getUserInfo(); 60 echo '<br /> <strong>Backtrace </strong>:'; 61 print_object($error->backtrace); 62 } 63 64 if ($CFG->debugdeveloper) { 65 //TODO: this is a wrong place to init PEAR! 66 $GLOBALS['_PEAR_default_error_mode'] = PEAR_ERROR_CALLBACK; 67 $GLOBALS['_PEAR_default_error_options'] = 'pear_handle_error'; 68 } 69 70 /** 71 * Initalize javascript for date type form element 72 * 73 * @staticvar bool $done make sure it gets initalize once. 74 * @global moodle_page $PAGE 75 */ 76 function form_init_date_js() { 77 global $PAGE; 78 static $done = false; 79 if (!$done) { 80 $done = true; 81 $calendar = \core_calendar\type_factory::get_calendar_instance(); 82 if ($calendar->get_name() !== 'gregorian') { 83 // The YUI2 calendar only supports the gregorian calendar type. 84 return; 85 } 86 $module = 'moodle-form-dateselector'; 87 $function = 'M.form.dateselector.init_date_selectors'; 88 $defaulttimezone = date_default_timezone_get(); 89 90 $config = array(array( 91 'firstdayofweek' => $calendar->get_starting_weekday(), 92 'mon' => date_format_string(strtotime("Monday"), '%a', $defaulttimezone), 93 'tue' => date_format_string(strtotime("Tuesday"), '%a', $defaulttimezone), 94 'wed' => date_format_string(strtotime("Wednesday"), '%a', $defaulttimezone), 95 'thu' => date_format_string(strtotime("Thursday"), '%a', $defaulttimezone), 96 'fri' => date_format_string(strtotime("Friday"), '%a', $defaulttimezone), 97 'sat' => date_format_string(strtotime("Saturday"), '%a', $defaulttimezone), 98 'sun' => date_format_string(strtotime("Sunday"), '%a', $defaulttimezone), 99 'january' => date_format_string(strtotime("January 1"), '%B', $defaulttimezone), 100 'february' => date_format_string(strtotime("February 1"), '%B', $defaulttimezone), 101 'march' => date_format_string(strtotime("March 1"), '%B', $defaulttimezone), 102 'april' => date_format_string(strtotime("April 1"), '%B', $defaulttimezone), 103 'may' => date_format_string(strtotime("May 1"), '%B', $defaulttimezone), 104 'june' => date_format_string(strtotime("June 1"), '%B', $defaulttimezone), 105 'july' => date_format_string(strtotime("July 1"), '%B', $defaulttimezone), 106 'august' => date_format_string(strtotime("August 1"), '%B', $defaulttimezone), 107 'september' => date_format_string(strtotime("September 1"), '%B', $defaulttimezone), 108 'october' => date_format_string(strtotime("October 1"), '%B', $defaulttimezone), 109 'november' => date_format_string(strtotime("November 1"), '%B', $defaulttimezone), 110 'december' => date_format_string(strtotime("December 1"), '%B', $defaulttimezone) 111 )); 112 $PAGE->requires->yui_module($module, $function, $config); 113 } 114 } 115 116 /** 117 * Wrapper that separates quickforms syntax from moodle code 118 * 119 * Moodle specific wrapper that separates quickforms syntax from moodle code. You won't directly 120 * use this class you should write a class definition which extends this class or a more specific 121 * subclass such a moodleform_mod for each form you want to display and/or process with formslib. 122 * 123 * You will write your own definition() method which performs the form set up. 124 * 125 * @package core_form 126 * @copyright 2006 Jamie Pratt <me@jamiep.org> 127 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 128 * @todo MDL-19380 rethink the file scanning 129 */ 130 abstract class moodleform { 131 /** @var string name of the form */ 132 protected $_formname; // form name 133 134 /** @var MoodleQuickForm quickform object definition */ 135 protected $_form; 136 137 /** @var mixed globals workaround */ 138 protected $_customdata; 139 140 /** @var array submitted form data when using mforms with ajax */ 141 protected $_ajaxformdata; 142 143 /** @var object definition_after_data executed flag */ 144 protected $_definition_finalized = false; 145 146 /** @var bool|null stores the validation result of this form or null if not yet validated */ 147 protected $_validated = null; 148 149 /** 150 * The constructor function calls the abstract function definition() and it will then 151 * process and clean and attempt to validate incoming data. 152 * 153 * It will call your custom validate method to validate data and will also check any rules 154 * you have specified in definition using addRule 155 * 156 * The name of the form (id attribute of the form) is automatically generated depending on 157 * the name you gave the class extending moodleform. You should call your class something 158 * like 159 * 160 * @param mixed $action the action attribute for the form. If empty defaults to auto detect the 161 * current url. If a moodle_url object then outputs params as hidden variables. 162 * @param mixed $customdata if your form defintion method needs access to data such as $course 163 * $cm, etc. to construct the form definition then pass it in this array. You can 164 * use globals for somethings. 165 * @param string $method if you set this to anything other than 'post' then _GET and _POST will 166 * be merged and used as incoming data to the form. 167 * @param string $target target frame for form submission. You will rarely use this. Don't use 168 * it if you don't need to as the target attribute is deprecated in xhtml strict. 169 * @param mixed $attributes you can pass a string of html attributes here or an array. 170 * Special attribute 'data-random-ids' will randomise generated elements ids. This 171 * is necessary when there are several forms on the same page. 172 * Special attribute 'data-double-submit-protection' set to 'off' will turn off 173 * double-submit protection JavaScript - this may be necessary if your form sends 174 * downloadable files in response to a submit button, and can't call 175 * \core_form\util::form_download_complete(); 176 * @param bool $editable 177 * @param array $ajaxformdata Forms submitted via ajax, must pass their data here, instead of relying on _GET and _POST. 178 */ 179 public function __construct($action=null, $customdata=null, $method='post', $target='', $attributes=null, $editable=true, 180 $ajaxformdata=null) { 181 global $CFG, $FULLME; 182 // no standard mform in moodle should allow autocomplete with the exception of user signup 183 if (empty($attributes)) { 184 $attributes = array('autocomplete'=>'off'); 185 } else if (is_array($attributes)) { 186 $attributes['autocomplete'] = 'off'; 187 } else { 188 if (strpos($attributes, 'autocomplete') === false) { 189 $attributes .= ' autocomplete="off" '; 190 } 191 } 192 193 194 if (empty($action)){ 195 // do not rely on PAGE->url here because dev often do not setup $actualurl properly in admin_externalpage_setup() 196 $action = strip_querystring($FULLME); 197 if (!empty($CFG->sslproxy)) { 198 // return only https links when using SSL proxy 199 $action = preg_replace('/^http:/', 'https:', $action, 1); 200 } 201 //TODO: use following instead of FULLME - see MDL-33015 202 //$action = strip_querystring(qualified_me()); 203 } 204 // Assign custom data first, so that get_form_identifier can use it. 205 $this->_customdata = $customdata; 206 $this->_formname = $this->get_form_identifier(); 207 $this->_ajaxformdata = $ajaxformdata; 208 209 $this->_form = new MoodleQuickForm($this->_formname, $method, $action, $target, $attributes, $ajaxformdata); 210 if (!$editable){ 211 $this->_form->hardFreeze(); 212 } 213 214 $this->definition(); 215 216 $this->_form->addElement('hidden', 'sesskey', null); // automatic sesskey protection 217 $this->_form->setType('sesskey', PARAM_RAW); 218 $this->_form->setDefault('sesskey', sesskey()); 219 $this->_form->addElement('hidden', '_qf__'.$this->_formname, null); // form submission marker 220 $this->_form->setType('_qf__'.$this->_formname, PARAM_RAW); 221 $this->_form->setDefault('_qf__'.$this->_formname, 1); 222 $this->_form->_setDefaultRuleMessages(); 223 224 // Hook to inject logic after the definition was provided. 225 $this->after_definition(); 226 227 // we have to know all input types before processing submission ;-) 228 $this->_process_submission($method); 229 } 230 231 /** 232 * Old syntax of class constructor. Deprecated in PHP7. 233 * 234 * @deprecated since Moodle 3.1 235 */ 236 public function moodleform($action=null, $customdata=null, $method='post', $target='', $attributes=null, $editable=true) { 237 debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER); 238 self::__construct($action, $customdata, $method, $target, $attributes, $editable); 239 } 240 241 /** 242 * It should returns unique identifier for the form. 243 * Currently it will return class name, but in case two same forms have to be 244 * rendered on same page then override function to get unique form identifier. 245 * e.g This is used on multiple self enrollments page. 246 * 247 * @return string form identifier. 248 */ 249 protected function get_form_identifier() { 250 $class = get_class($this); 251 252 return preg_replace('/[^a-z0-9_]/i', '_', $class); 253 } 254 255 /** 256 * To autofocus on first form element or first element with error. 257 * 258 * @param string $name if this is set then the focus is forced to a field with this name 259 * @return string javascript to select form element with first error or 260 * first element if no errors. Use this as a parameter 261 * when calling print_header 262 */ 263 function focus($name=NULL) { 264 $form =& $this->_form; 265 $elkeys = array_keys($form->_elementIndex); 266 $error = false; 267 if (isset($form->_errors) && 0 != count($form->_errors)){ 268 $errorkeys = array_keys($form->_errors); 269 $elkeys = array_intersect($elkeys, $errorkeys); 270 $error = true; 271 } 272 273 if ($error or empty($name)) { 274 $names = array(); 275 while (empty($names) and !empty($elkeys)) { 276 $el = array_shift($elkeys); 277 $names = $form->_getElNamesRecursive($el); 278 } 279 if (!empty($names)) { 280 $name = array_shift($names); 281 } 282 } 283 284 $focus = ''; 285 if (!empty($name)) { 286 $focus = 'forms[\''.$form->getAttribute('id').'\'].elements[\''.$name.'\']'; 287 } 288 289 return $focus; 290 } 291 292 /** 293 * Internal method. Alters submitted data to be suitable for quickforms processing. 294 * Must be called when the form is fully set up. 295 * 296 * @param string $method name of the method which alters submitted data 297 */ 298 function _process_submission($method) { 299 $submission = array(); 300 if (!empty($this->_ajaxformdata)) { 301 $submission = $this->_ajaxformdata; 302 } else if ($method == 'post') { 303 if (!empty($_POST)) { 304 $submission = $_POST; 305 } 306 } else { 307 $submission = $_GET; 308 merge_query_params($submission, $_POST); // Emulate handling of parameters in xxxx_param(). 309 } 310 311 // following trick is needed to enable proper sesskey checks when using GET forms 312 // the _qf__.$this->_formname serves as a marker that form was actually submitted 313 if (array_key_exists('_qf__'.$this->_formname, $submission) and $submission['_qf__'.$this->_formname] == 1) { 314 if (!confirm_sesskey()) { 315 throw new \moodle_exception('invalidsesskey'); 316 } 317 $files = $_FILES; 318 } else { 319 $submission = array(); 320 $files = array(); 321 } 322 $this->detectMissingSetType(); 323 324 $this->_form->updateSubmission($submission, $files); 325 } 326 327 /** 328 * Internal method - should not be used anywhere. 329 * @deprecated since 2.6 330 * @return array $_POST. 331 */ 332 protected function _get_post_params() { 333 return $_POST; 334 } 335 336 /** 337 * Internal method. Validates all old-style deprecated uploaded files. 338 * The new way is to upload files via repository api. 339 * 340 * @param array $files list of files to be validated 341 * @return bool|array Success or an array of errors 342 */ 343 function _validate_files(&$files) { 344 global $CFG, $COURSE; 345 346 $files = array(); 347 348 if (empty($_FILES)) { 349 // we do not need to do any checks because no files were submitted 350 // note: server side rules do not work for files - use custom verification in validate() instead 351 return true; 352 } 353 354 $errors = array(); 355 $filenames = array(); 356 357 // now check that we really want each file 358 foreach ($_FILES as $elname=>$file) { 359 $required = $this->_form->isElementRequired($elname); 360 361 if ($file['error'] == 4 and $file['size'] == 0) { 362 if ($required) { 363 $errors[$elname] = get_string('required'); 364 } 365 unset($_FILES[$elname]); 366 continue; 367 } 368 369 if (!empty($file['error'])) { 370 $errors[$elname] = file_get_upload_error($file['error']); 371 unset($_FILES[$elname]); 372 continue; 373 } 374 375 if (!is_uploaded_file($file['tmp_name'])) { 376 // TODO: improve error message 377 $errors[$elname] = get_string('error'); 378 unset($_FILES[$elname]); 379 continue; 380 } 381 382 if (!$this->_form->elementExists($elname) or !$this->_form->getElementType($elname)=='file') { 383 // hmm, this file was not requested 384 unset($_FILES[$elname]); 385 continue; 386 } 387 388 // NOTE: the viruses are scanned in file picker, no need to deal with them here. 389 390 $filename = clean_param($_FILES[$elname]['name'], PARAM_FILE); 391 if ($filename === '') { 392 // TODO: improve error message - wrong chars 393 $errors[$elname] = get_string('error'); 394 unset($_FILES[$elname]); 395 continue; 396 } 397 if (in_array($filename, $filenames)) { 398 // TODO: improve error message - duplicate name 399 $errors[$elname] = get_string('error'); 400 unset($_FILES[$elname]); 401 continue; 402 } 403 $filenames[] = $filename; 404 $_FILES[$elname]['name'] = $filename; 405 406 $files[$elname] = $_FILES[$elname]['tmp_name']; 407 } 408 409 // return errors if found 410 if (count($errors) == 0){ 411 return true; 412 413 } else { 414 $files = array(); 415 return $errors; 416 } 417 } 418 419 /** 420 * Internal method. Validates filepicker and filemanager files if they are 421 * set as required fields. Also, sets the error message if encountered one. 422 * 423 * @return bool|array with errors 424 */ 425 protected function validate_draft_files() { 426 global $USER; 427 $mform =& $this->_form; 428 429 $errors = array(); 430 //Go through all the required elements and make sure you hit filepicker or 431 //filemanager element. 432 foreach ($mform->_rules as $elementname => $rules) { 433 $elementtype = $mform->getElementType($elementname); 434 //If element is of type filepicker then do validation 435 if (($elementtype == 'filepicker') || ($elementtype == 'filemanager')){ 436 //Check if rule defined is required rule 437 foreach ($rules as $rule) { 438 if ($rule['type'] == 'required') { 439 $draftid = (int)$mform->getSubmitValue($elementname); 440 $fs = get_file_storage(); 441 $context = context_user::instance($USER->id); 442 if (!$files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, 'id DESC', false)) { 443 $errors[$elementname] = $rule['message']; 444 } 445 } 446 } 447 } 448 } 449 // Check all the filemanager elements to make sure they do not have too many 450 // files in them. 451 foreach ($mform->_elements as $element) { 452 if ($element->_type == 'filemanager') { 453 $maxfiles = $element->getMaxfiles(); 454 if ($maxfiles > 0) { 455 $draftid = (int)$element->getValue(); 456 $fs = get_file_storage(); 457 $context = context_user::instance($USER->id); 458 $files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, '', false); 459 if (count($files) > $maxfiles) { 460 $errors[$element->getName()] = get_string('err_maxfiles', 'form', $maxfiles); 461 } 462 } 463 } 464 } 465 if (empty($errors)) { 466 return true; 467 } else { 468 return $errors; 469 } 470 } 471 472 /** 473 * Load in existing data as form defaults. Usually new entry defaults are stored directly in 474 * form definition (new entry form); this function is used to load in data where values 475 * already exist and data is being edited (edit entry form). 476 * 477 * note: $slashed param removed 478 * 479 * @param stdClass|array $default_values object or array of default values 480 */ 481 function set_data($default_values) { 482 if (is_object($default_values)) { 483 $default_values = (array)$default_values; 484 } 485 $this->_form->setDefaults($default_values); 486 } 487 488 /** 489 * Check that form was submitted. Does not check validity of submitted data. 490 * 491 * @return bool true if form properly submitted 492 */ 493 function is_submitted() { 494 return $this->_form->isSubmitted(); 495 } 496 497 /** 498 * Checks if button pressed is not for submitting the form 499 * 500 * @staticvar bool $nosubmit keeps track of no submit button 501 * @return bool 502 */ 503 function no_submit_button_pressed(){ 504 static $nosubmit = null; // one check is enough 505 if (!is_null($nosubmit)){ 506 return $nosubmit; 507 } 508 $mform =& $this->_form; 509 $nosubmit = false; 510 if (!$this->is_submitted()){ 511 return false; 512 } 513 foreach ($mform->_noSubmitButtons as $nosubmitbutton){ 514 if ($this->optional_param($nosubmitbutton, 0, PARAM_RAW)) { 515 $nosubmit = true; 516 break; 517 } 518 } 519 return $nosubmit; 520 } 521 522 /** 523 * Returns an element of multi-dimensional array given the list of keys 524 * 525 * Example: 526 * $array['a']['b']['c'] = 13; 527 * $v = $this->get_array_value_by_keys($array, ['a', 'b', 'c']); 528 * 529 * Will result it $v==13 530 * 531 * @param array $array 532 * @param array $keys 533 * @return mixed returns null if keys not present 534 */ 535 protected function get_array_value_by_keys(array $array, array $keys) { 536 $value = $array; 537 foreach ($keys as $key) { 538 if (array_key_exists($key, $value)) { 539 $value = $value[$key]; 540 } else { 541 return null; 542 } 543 } 544 return $value; 545 } 546 547 /** 548 * Checks if a parameter was passed in the previous form submission 549 * 550 * @param string $name the name of the page parameter we want, for example 'id' or 'element[sub][13]' 551 * @param mixed $default the default value to return if nothing is found 552 * @param string $type expected type of parameter 553 * @return mixed 554 */ 555 public function optional_param($name, $default, $type) { 556 $nameparsed = []; 557 // Convert element name into a sequence of keys, for example 'element[sub][13]' -> ['element', 'sub', '13']. 558 parse_str($name . '=1', $nameparsed); 559 $keys = []; 560 while (is_array($nameparsed)) { 561 $key = key($nameparsed); 562 $keys[] = $key; 563 $nameparsed = $nameparsed[$key]; 564 } 565 566 // Search for the element first in $this->_ajaxformdata, then in $_POST and then in $_GET. 567 if (($value = $this->get_array_value_by_keys($this->_ajaxformdata ?? [], $keys)) !== null || 568 ($value = $this->get_array_value_by_keys($_POST, $keys)) !== null || 569 ($value = $this->get_array_value_by_keys($_GET, $keys)) !== null) { 570 return $type == PARAM_RAW ? $value : clean_param($value, $type); 571 } 572 573 return $default; 574 } 575 576 /** 577 * Check that form data is valid. 578 * You should almost always use this, rather than {@link validate_defined_fields} 579 * 580 * @return bool true if form data valid 581 */ 582 function is_validated() { 583 //finalize the form definition before any processing 584 if (!$this->_definition_finalized) { 585 $this->_definition_finalized = true; 586 $this->definition_after_data(); 587 } 588 589 return $this->validate_defined_fields(); 590 } 591 592 /** 593 * Validate the form. 594 * 595 * You almost always want to call {@link is_validated} instead of this 596 * because it calls {@link definition_after_data} first, before validating the form, 597 * which is what you want in 99% of cases. 598 * 599 * This is provided as a separate function for those special cases where 600 * you want the form validated before definition_after_data is called 601 * for example, to selectively add new elements depending on a no_submit_button press, 602 * but only when the form is valid when the no_submit_button is pressed, 603 * 604 * @param bool $validateonnosubmit optional, defaults to false. The default behaviour 605 * is NOT to validate the form when a no submit button has been pressed. 606 * pass true here to override this behaviour 607 * 608 * @return bool true if form data valid 609 */ 610 function validate_defined_fields($validateonnosubmit=false) { 611 $mform =& $this->_form; 612 if ($this->no_submit_button_pressed() && empty($validateonnosubmit)){ 613 return false; 614 } elseif ($this->_validated === null) { 615 $internal_val = $mform->validate(); 616 617 $files = array(); 618 $file_val = $this->_validate_files($files); 619 //check draft files for validation and flag them if required files 620 //are not in draft area. 621 $draftfilevalue = $this->validate_draft_files(); 622 623 if ($file_val !== true && $draftfilevalue !== true) { 624 $file_val = array_merge($file_val, $draftfilevalue); 625 } else if ($draftfilevalue !== true) { 626 $file_val = $draftfilevalue; 627 } //default is file_val, so no need to assign. 628 629 if ($file_val !== true) { 630 if (!empty($file_val)) { 631 foreach ($file_val as $element=>$msg) { 632 $mform->setElementError($element, $msg); 633 } 634 } 635 $file_val = false; 636 } 637 638 // Give the elements a chance to perform an implicit validation. 639 $element_val = true; 640 foreach ($mform->_elements as $element) { 641 if (method_exists($element, 'validateSubmitValue')) { 642 $value = $mform->getSubmitValue($element->getName()); 643 $result = $element->validateSubmitValue($value); 644 if (!empty($result) && is_string($result)) { 645 $element_val = false; 646 $mform->setElementError($element->getName(), $result); 647 } 648 } 649 } 650 651 // Let the form instance validate the submitted values. 652 $data = $mform->exportValues(); 653 $moodle_val = $this->validation($data, $files); 654 if ((is_array($moodle_val) && count($moodle_val)!==0)) { 655 // non-empty array means errors 656 foreach ($moodle_val as $element=>$msg) { 657 $mform->setElementError($element, $msg); 658 } 659 $moodle_val = false; 660 661 } else { 662 // anything else means validation ok 663 $moodle_val = true; 664 } 665 666 $this->_validated = ($internal_val and $element_val and $moodle_val and $file_val); 667 } 668 return $this->_validated; 669 } 670 671 /** 672 * Return true if a cancel button has been pressed resulting in the form being submitted. 673 * 674 * @return bool true if a cancel button has been pressed 675 */ 676 function is_cancelled(){ 677 $mform =& $this->_form; 678 if ($mform->isSubmitted()){ 679 foreach ($mform->_cancelButtons as $cancelbutton){ 680 if ($this->optional_param($cancelbutton, 0, PARAM_RAW)) { 681 return true; 682 } 683 } 684 } 685 return false; 686 } 687 688 /** 689 * Return submitted data if properly submitted or returns NULL if validation fails or 690 * if there is no submitted data. 691 * 692 * note: $slashed param removed 693 * 694 * @return stdClass|null submitted data; NULL if not valid or not submitted or cancelled 695 */ 696 function get_data() { 697 $mform =& $this->_form; 698 699 if (!$this->is_cancelled() and $this->is_submitted() and $this->is_validated()) { 700 $data = $mform->exportValues(); 701 unset($data['sesskey']); // we do not need to return sesskey 702 unset($data['_qf__'.$this->_formname]); // we do not need the submission marker too 703 if (empty($data)) { 704 return NULL; 705 } else { 706 return (object)$data; 707 } 708 } else { 709 return NULL; 710 } 711 } 712 713 /** 714 * Return submitted data without validation or NULL if there is no submitted data. 715 * note: $slashed param removed 716 * 717 * @return stdClass|null submitted data; NULL if not submitted 718 */ 719 function get_submitted_data() { 720 $mform =& $this->_form; 721 722 if ($this->is_submitted()) { 723 $data = $mform->exportValues(); 724 unset($data['sesskey']); // we do not need to return sesskey 725 unset($data['_qf__'.$this->_formname]); // we do not need the submission marker too 726 if (empty($data)) { 727 return NULL; 728 } else { 729 return (object)$data; 730 } 731 } else { 732 return NULL; 733 } 734 } 735 736 /** 737 * Save verified uploaded files into directory. Upload process can be customised from definition() 738 * 739 * @deprecated since Moodle 2.0 740 * @todo MDL-31294 remove this api 741 * @see moodleform::save_stored_file() 742 * @see moodleform::save_file() 743 * @param string $destination path where file should be stored 744 * @return bool Always false 745 */ 746 function save_files($destination) { 747 debugging('Not used anymore, please fix code! Use save_stored_file() or save_file() instead'); 748 return false; 749 } 750 751 /** 752 * Returns name of uploaded file. 753 * 754 * @param string $elname first element if null 755 * @return string|bool false in case of failure, string if ok 756 */ 757 function get_new_filename($elname=null) { 758 global $USER; 759 760 if (!$this->is_submitted() or !$this->is_validated()) { 761 return false; 762 } 763 764 if (is_null($elname)) { 765 if (empty($_FILES)) { 766 return false; 767 } 768 reset($_FILES); 769 $elname = key($_FILES); 770 } 771 772 if (empty($elname)) { 773 return false; 774 } 775 776 $element = $this->_form->getElement($elname); 777 778 if ($element instanceof MoodleQuickForm_filepicker || $element instanceof MoodleQuickForm_filemanager) { 779 $values = $this->_form->exportValues($elname); 780 if (empty($values[$elname])) { 781 return false; 782 } 783 $draftid = $values[$elname]; 784 $fs = get_file_storage(); 785 $context = context_user::instance($USER->id); 786 if (!$files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, 'id DESC', false)) { 787 return false; 788 } 789 $file = reset($files); 790 return $file->get_filename(); 791 } 792 793 if (!isset($_FILES[$elname])) { 794 return false; 795 } 796 797 return $_FILES[$elname]['name']; 798 } 799 800 /** 801 * Save file to standard filesystem 802 * 803 * @param string $elname name of element 804 * @param string $pathname full path name of file 805 * @param bool $override override file if exists 806 * @return bool success 807 */ 808 function save_file($elname, $pathname, $override=false) { 809 global $USER; 810 811 if (!$this->is_submitted() or !$this->is_validated()) { 812 return false; 813 } 814 if (file_exists($pathname)) { 815 if ($override) { 816 if (!@unlink($pathname)) { 817 return false; 818 } 819 } else { 820 return false; 821 } 822 } 823 824 $element = $this->_form->getElement($elname); 825 826 if ($element instanceof MoodleQuickForm_filepicker || $element instanceof MoodleQuickForm_filemanager) { 827 $values = $this->_form->exportValues($elname); 828 if (empty($values[$elname])) { 829 return false; 830 } 831 $draftid = $values[$elname]; 832 $fs = get_file_storage(); 833 $context = context_user::instance($USER->id); 834 if (!$files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, 'id DESC', false)) { 835 return false; 836 } 837 $file = reset($files); 838 839 return $file->copy_content_to($pathname); 840 841 } else if (isset($_FILES[$elname])) { 842 return copy($_FILES[$elname]['tmp_name'], $pathname); 843 } 844 845 return false; 846 } 847 848 /** 849 * Returns a temporary file, do not forget to delete after not needed any more. 850 * 851 * @param string $elname name of the elmenet 852 * @return string|bool either string or false 853 */ 854 function save_temp_file($elname) { 855 if (!$this->get_new_filename($elname)) { 856 return false; 857 } 858 if (!$dir = make_temp_directory('forms')) { 859 return false; 860 } 861 if (!$tempfile = tempnam($dir, 'tempup_')) { 862 return false; 863 } 864 if (!$this->save_file($elname, $tempfile, true)) { 865 // something went wrong 866 @unlink($tempfile); 867 return false; 868 } 869 870 return $tempfile; 871 } 872 873 /** 874 * Get draft files of a form element 875 * This is a protected method which will be used only inside moodleforms 876 * 877 * @param string $elname name of element 878 * @return array|bool|null 879 */ 880 protected function get_draft_files($elname) { 881 global $USER; 882 883 if (!$this->is_submitted()) { 884 return false; 885 } 886 887 $element = $this->_form->getElement($elname); 888 889 if ($element instanceof MoodleQuickForm_filepicker || $element instanceof MoodleQuickForm_filemanager) { 890 $values = $this->_form->exportValues($elname); 891 if (empty($values[$elname])) { 892 return false; 893 } 894 $draftid = $values[$elname]; 895 $fs = get_file_storage(); 896 $context = context_user::instance($USER->id); 897 if (!$files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, 'id DESC', false)) { 898 return null; 899 } 900 return $files; 901 } 902 return null; 903 } 904 905 /** 906 * Save file to local filesystem pool 907 * 908 * @param string $elname name of element 909 * @param int $newcontextid id of context 910 * @param string $newcomponent name of the component 911 * @param string $newfilearea name of file area 912 * @param int $newitemid item id 913 * @param string $newfilepath path of file where it get stored 914 * @param string $newfilename use specified filename, if not specified name of uploaded file used 915 * @param bool $overwrite overwrite file if exists 916 * @param int $newuserid new userid if required 917 * @return mixed stored_file object or false if error; may throw exception if duplicate found 918 */ 919 function save_stored_file($elname, $newcontextid, $newcomponent, $newfilearea, $newitemid, $newfilepath='/', 920 $newfilename=null, $overwrite=false, $newuserid=null) { 921 global $USER; 922 923 if (!$this->is_submitted() or !$this->is_validated()) { 924 return false; 925 } 926 927 if (empty($newuserid)) { 928 $newuserid = $USER->id; 929 } 930 931 $element = $this->_form->getElement($elname); 932 $fs = get_file_storage(); 933 934 if ($element instanceof MoodleQuickForm_filepicker) { 935 $values = $this->_form->exportValues($elname); 936 if (empty($values[$elname])) { 937 return false; 938 } 939 $draftid = $values[$elname]; 940 $context = context_user::instance($USER->id); 941 if (!$files = $fs->get_area_files($context->id, 'user' ,'draft', $draftid, 'id DESC', false)) { 942 return false; 943 } 944 $file = reset($files); 945 if (is_null($newfilename)) { 946 $newfilename = $file->get_filename(); 947 } 948 949 if ($overwrite) { 950 if ($oldfile = $fs->get_file($newcontextid, $newcomponent, $newfilearea, $newitemid, $newfilepath, $newfilename)) { 951 if (!$oldfile->delete()) { 952 return false; 953 } 954 } 955 } 956 957 $file_record = array('contextid'=>$newcontextid, 'component'=>$newcomponent, 'filearea'=>$newfilearea, 'itemid'=>$newitemid, 958 'filepath'=>$newfilepath, 'filename'=>$newfilename, 'userid'=>$newuserid); 959 return $fs->create_file_from_storedfile($file_record, $file); 960 961 } else if (isset($_FILES[$elname])) { 962 $filename = is_null($newfilename) ? $_FILES[$elname]['name'] : $newfilename; 963 964 if ($overwrite) { 965 if ($oldfile = $fs->get_file($newcontextid, $newcomponent, $newfilearea, $newitemid, $newfilepath, $newfilename)) { 966 if (!$oldfile->delete()) { 967 return false; 968 } 969 } 970 } 971 972 $file_record = array('contextid'=>$newcontextid, 'component'=>$newcomponent, 'filearea'=>$newfilearea, 'itemid'=>$newitemid, 973 'filepath'=>$newfilepath, 'filename'=>$newfilename, 'userid'=>$newuserid); 974 return $fs->create_file_from_pathname($file_record, $_FILES[$elname]['tmp_name']); 975 } 976 977 return false; 978 } 979 980 /** 981 * Get content of uploaded file. 982 * 983 * @param string $elname name of file upload element 984 * @return string|bool false in case of failure, string if ok 985 */ 986 function get_file_content($elname) { 987 global $USER; 988 989 if (!$this->is_submitted() or !$this->is_validated()) { 990 return false; 991 } 992 993 $element = $this->_form->getElement($elname); 994 995 if ($element instanceof MoodleQuickForm_filepicker || $element instanceof MoodleQuickForm_filemanager) { 996 $values = $this->_form->exportValues($elname); 997 if (empty($values[$elname])) { 998 return false; 999 } 1000 $draftid = $values[$elname]; 1001 $fs = get_file_storage(); 1002 $context = context_user::instance($USER->id); 1003 if (!$files = $fs->get_area_files($context->id, 'user', 'draft', $draftid, 'id DESC', false)) { 1004 return false; 1005 } 1006 $file = reset($files); 1007 1008 return $file->get_content(); 1009 1010 } else if (isset($_FILES[$elname])) { 1011 return file_get_contents($_FILES[$elname]['tmp_name']); 1012 } 1013 1014 return false; 1015 } 1016 1017 /** 1018 * Print html form. 1019 */ 1020 function display() { 1021 //finalize the form definition if not yet done 1022 if (!$this->_definition_finalized) { 1023 $this->_definition_finalized = true; 1024 $this->definition_after_data(); 1025 } 1026 1027 $this->_form->display(); 1028 } 1029 1030 /** 1031 * Renders the html form (same as display, but returns the result). 1032 * 1033 * Note that you can only output this rendered result once per page, as 1034 * it contains IDs which must be unique. 1035 * 1036 * @return string HTML code for the form 1037 */ 1038 public function render() { 1039 ob_start(); 1040 $this->display(); 1041 $out = ob_get_contents(); 1042 ob_end_clean(); 1043 return $out; 1044 } 1045 1046 /** 1047 * Form definition. Abstract method - always override! 1048 */ 1049 protected abstract function definition(); 1050 1051 /** 1052 * After definition hook. 1053 * 1054 * This is useful for intermediate classes to inject logic after the definition was 1055 * provided without requiring developers to call the parent {{@link self::definition()}} 1056 * as it's not obvious by design. The 'intermediate' class is 'MyClass extends 1057 * IntermediateClass extends moodleform'. 1058 * 1059 * Classes overriding this method should always call the parent. We may not add 1060 * anything specifically in this instance of the method, but intermediate classes 1061 * are likely to do so, and so it is a good practice to always call the parent. 1062 * 1063 * @return void 1064 */ 1065 protected function after_definition() { 1066 } 1067 1068 /** 1069 * Dummy stub method - override if you need to setup the form depending on current 1070 * values. This method is called after definition(), data submission and set_data(). 1071 * All form setup that is dependent on form values should go in here. 1072 */ 1073 function definition_after_data(){ 1074 } 1075 1076 /** 1077 * Dummy stub method - override if you needed to perform some extra validation. 1078 * If there are errors return array of errors ("fieldname"=>"error message"), 1079 * otherwise true if ok. 1080 * 1081 * Server side rules do not work for uploaded files, implement serverside rules here if needed. 1082 * 1083 * @param array $data array of ("fieldname"=>value) of submitted data 1084 * @param array $files array of uploaded files "element_name"=>tmp_file_path 1085 * @return array of "element_name"=>"error_description" if there are errors, 1086 * or an empty array if everything is OK (true allowed for backwards compatibility too). 1087 */ 1088 function validation($data, $files) { 1089 return array(); 1090 } 1091 1092 /** 1093 * Helper used by {@link repeat_elements()}. 1094 * 1095 * @param int $i the index of this element. 1096 * @param HTML_QuickForm_element $elementclone 1097 * @param array $namecloned array of names 1098 */ 1099 function repeat_elements_fix_clone($i, $elementclone, &$namecloned) { 1100 $name = $elementclone->getName(); 1101 $namecloned[] = $name; 1102 1103 if (!empty($name)) { 1104 $elementclone->setName($name."[$i]"); 1105 } 1106 1107 if (is_a($elementclone, 'HTML_QuickForm_header')) { 1108 $value = $elementclone->_text; 1109 $elementclone->setValue(str_replace('{no}', ($i+1), $value)); 1110 1111 } else if (is_a($elementclone, 'HTML_QuickForm_submit') || is_a($elementclone, 'HTML_QuickForm_button')) { 1112 $elementclone->setValue(str_replace('{no}', ($i+1), $elementclone->getValue())); 1113 1114 } else { 1115 $value=$elementclone->getLabel(); 1116 $elementclone->setLabel(str_replace('{no}', ($i+1), $value)); 1117 } 1118 } 1119 1120 /** 1121 * Method to add a repeating group of elements to a form. 1122 * 1123 * @param array $elementobjs Array of elements or groups of elements that are to be repeated 1124 * @param int $repeats no of times to repeat elements initially 1125 * @param array $options a nested array. The first array key is the element name. 1126 * the second array key is the type of option to set, and depend on that option, 1127 * the value takes different forms. 1128 * 'default' - default value to set. Can include '{no}' which is replaced by the repeat number. 1129 * 'type' - PARAM_* type. 1130 * 'helpbutton' - array containing the helpbutton params. 1131 * 'disabledif' - array containing the disabledIf() arguments after the element name. 1132 * 'rule' - array containing the addRule arguments after the element name. 1133 * 'expanded' - whether this section of the form should be expanded by default. (Name be a header element.) 1134 * 'advanced' - whether this element is hidden by 'Show more ...'. 1135 * @param string $repeathiddenname name for hidden element storing no of repeats in this form 1136 * @param string $addfieldsname name for button to add more fields 1137 * @param int $addfieldsno how many fields to add at a time 1138 * @param string $addstring name of button, {no} is replaced by no of blanks that will be added. 1139 * @param bool $addbuttoninside if true, don't call closeHeaderBefore($addfieldsname). Default false. 1140 * @param string $deletebuttonname if specified, treats the no-submit button with this name as a "delete element" button 1141 * in each of the elements 1142 * @return int no of repeats of element in this page 1143 */ 1144 public function repeat_elements($elementobjs, $repeats, $options, $repeathiddenname, 1145 $addfieldsname, $addfieldsno = 5, $addstring = null, $addbuttoninside = false, 1146 $deletebuttonname = '') { 1147 if ($addstring === null) { 1148 $addstring = get_string('addfields', 'form', $addfieldsno); 1149 } else { 1150 $addstring = str_ireplace('{no}', $addfieldsno, $addstring); 1151 } 1152 $repeats = $this->optional_param($repeathiddenname, $repeats, PARAM_INT); 1153 $addfields = $this->optional_param($addfieldsname, '', PARAM_TEXT); 1154 $oldrepeats = $repeats; 1155 if (!empty($addfields)){ 1156 $repeats += $addfieldsno; 1157 } 1158 $mform =& $this->_form; 1159 $mform->registerNoSubmitButton($addfieldsname); 1160 $mform->addElement('hidden', $repeathiddenname, $repeats); 1161 $mform->setType($repeathiddenname, PARAM_INT); 1162 //value not to be overridden by submitted value 1163 $mform->setConstants(array($repeathiddenname=>$repeats)); 1164 $namecloned = array(); 1165 $no = 1; 1166 for ($i = 0; $i < $repeats; $i++) { 1167 if ($deletebuttonname) { 1168 $mform->registerNoSubmitButton($deletebuttonname . "[$i]"); 1169 $isdeleted = $this->optional_param($deletebuttonname . "[$i]", false, PARAM_RAW) || 1170 $this->optional_param($deletebuttonname . "-hidden[$i]", false, PARAM_RAW); 1171 if ($isdeleted) { 1172 $mform->addElement('hidden', $deletebuttonname . "-hidden[$i]", 1); 1173 $mform->setType($deletebuttonname . "-hidden[$i]", PARAM_INT); 1174 continue; 1175 } 1176 } 1177 foreach ($elementobjs as $elementobj){ 1178 $elementclone = fullclone($elementobj); 1179 $this->repeat_elements_fix_clone($i, $elementclone, $namecloned); 1180 1181 if ($elementclone instanceof HTML_QuickForm_group && !$elementclone->_appendName) { 1182 foreach ($elementclone->getElements() as $el) { 1183 $this->repeat_elements_fix_clone($i, $el, $namecloned); 1184 } 1185 $elementclone->setLabel(str_replace('{no}', $no, $elementclone->getLabel())); 1186 } else if ($elementobj instanceof \HTML_QuickForm_submit && $elementobj->getName() == $deletebuttonname) { 1187 // Mark the "Delete" button as no-submit. 1188 $onclick = $elementclone->getAttribute('onclick'); 1189 $skip = 'skipClientValidation = true;'; 1190 $onclick = ($onclick !== null) ? $skip . ' ' . $onclick : $skip; 1191 $elementclone->updateAttributes(['data-skip-validation' => 1, 'data-no-submit' => 1, 'onclick' => $onclick]); 1192 } 1193 1194 // Mark newly created elements, so they know not to look for any submitted data. 1195 if ($i >= $oldrepeats) { 1196 $mform->note_new_repeat($elementclone->getName()); 1197 } 1198 1199 $mform->addElement($elementclone); 1200 $no++; 1201 } 1202 } 1203 for ($i=0; $i<$repeats; $i++) { 1204 foreach ($options as $elementname => $elementoptions){ 1205 $pos=strpos($elementname, '['); 1206 if ($pos!==FALSE){ 1207 $realelementname = substr($elementname, 0, $pos)."[$i]"; 1208 $realelementname .= substr($elementname, $pos); 1209 }else { 1210 $realelementname = $elementname."[$i]"; 1211 } 1212 foreach ($elementoptions as $option => $params){ 1213 1214 switch ($option){ 1215 case 'default' : 1216 $mform->setDefault($realelementname, str_replace('{no}', $i + 1, $params)); 1217 break; 1218 case 'helpbutton' : 1219 $params = array_merge(array($realelementname), $params); 1220 call_user_func_array(array(&$mform, 'addHelpButton'), $params); 1221 break; 1222 case 'disabledif' : 1223 case 'hideif' : 1224 $pos = strpos($params[0], '['); 1225 $ending = ''; 1226 if ($pos !== false) { 1227 $ending = substr($params[0], $pos); 1228 $params[0] = substr($params[0], 0, $pos); 1229 } 1230 foreach ($namecloned as $num => $name){ 1231 if ($params[0] == $name){ 1232 $params[0] = $params[0] . "[$i]" . $ending; 1233 break; 1234 } 1235 } 1236 $params = array_merge(array($realelementname), $params); 1237 $function = ($option === 'disabledif') ? 'disabledIf' : 'hideIf'; 1238 call_user_func_array(array(&$mform, $function), $params); 1239 break; 1240 case 'rule' : 1241 if (is_string($params)){ 1242 $params = array(null, $params, null, 'client'); 1243 } 1244 $params = array_merge(array($realelementname), $params); 1245 call_user_func_array(array(&$mform, 'addRule'), $params); 1246 break; 1247 1248 case 'type': 1249 $mform->setType($realelementname, $params); 1250 break; 1251 1252 case 'expanded': 1253 $mform->setExpanded($realelementname, $params); 1254 break; 1255 1256 case 'advanced' : 1257 $mform->setAdvanced($realelementname, $params); 1258 break; 1259 } 1260 } 1261 } 1262 } 1263 $mform->addElement('submit', $addfieldsname, $addstring, [], false); 1264 1265 if (!$addbuttoninside) { 1266 $mform->closeHeaderBefore($addfieldsname); 1267 } 1268 1269 return $repeats; 1270 } 1271 1272 /** 1273 * Adds a link/button that controls the checked state of a group of checkboxes. 1274 * 1275 * @param int $groupid The id of the group of advcheckboxes this element controls 1276 * @param string $text The text of the link. Defaults to selectallornone ("select all/none") 1277 * @param array $attributes associative array of HTML attributes 1278 * @param int $originalValue The original general state of the checkboxes before the user first clicks this element 1279 */ 1280 function add_checkbox_controller($groupid, $text = null, $attributes = null, $originalValue = 0) { 1281 global $CFG, $PAGE; 1282 1283 // Name of the controller button 1284 $checkboxcontrollername = 'nosubmit_checkbox_controller' . $groupid; 1285 $checkboxcontrollerparam = 'checkbox_controller'. $groupid; 1286 $checkboxgroupclass = 'checkboxgroup'.$groupid; 1287 1288 // Set the default text if none was specified 1289 if (empty($text)) { 1290 $text = get_string('selectallornone', 'form'); 1291 } 1292 1293 $mform = $this->_form; 1294 $selectvalue = $this->optional_param($checkboxcontrollerparam, null, PARAM_INT); 1295 $contollerbutton = $this->optional_param($checkboxcontrollername, null, PARAM_ALPHAEXT); 1296 1297 $newselectvalue = $selectvalue; 1298 if (is_null($selectvalue)) { 1299 $newselectvalue = $originalValue; 1300 } else if (!is_null($contollerbutton)) { 1301 $newselectvalue = (int) !$selectvalue; 1302 } 1303 // set checkbox state depending on orignal/submitted value by controoler button 1304 if (!is_null($contollerbutton) || is_null($selectvalue)) { 1305 foreach ($mform->_elements as $element) { 1306 if (($element instanceof MoodleQuickForm_advcheckbox) && 1307 $element->getAttribute('class') == $checkboxgroupclass && 1308 !$element->isFrozen()) { 1309 $mform->setConstants(array($element->getName() => $newselectvalue)); 1310 } 1311 } 1312 } 1313 1314 $mform->addElement('hidden', $checkboxcontrollerparam, $newselectvalue, array('id' => "id_".$checkboxcontrollerparam)); 1315 $mform->setType($checkboxcontrollerparam, PARAM_INT); 1316 $mform->setConstants(array($checkboxcontrollerparam => $newselectvalue)); 1317 1318 $PAGE->requires->yui_module('moodle-form-checkboxcontroller', 'M.form.checkboxcontroller', 1319 array( 1320 array('groupid' => $groupid, 1321 'checkboxclass' => $checkboxgroupclass, 1322 'checkboxcontroller' => $checkboxcontrollerparam, 1323 'controllerbutton' => $checkboxcontrollername) 1324 ) 1325 ); 1326 1327 require_once("$CFG->libdir/form/submit.php"); 1328 $submitlink = new MoodleQuickForm_submit($checkboxcontrollername, $attributes); 1329 $mform->addElement($submitlink); 1330 $mform->registerNoSubmitButton($checkboxcontrollername); 1331 $mform->setDefault($checkboxcontrollername, $text); 1332 } 1333 1334 /** 1335 * Use this method to a cancel and submit button to the end of your form. Pass a param of false 1336 * if you don't want a cancel button in your form. If you have a cancel button make sure you 1337 * check for it being pressed using is_cancelled() and redirecting if it is true before trying to 1338 * get data with get_data(). 1339 * 1340 * @param bool $cancel whether to show cancel button, default true 1341 * @param string $submitlabel label for submit button, defaults to get_string('savechanges') 1342 */ 1343 function add_action_buttons($cancel = true, $submitlabel=null){ 1344 if (is_null($submitlabel)){ 1345 $submitlabel = get_string('savechanges'); 1346 } 1347 $mform =& $this->_form; 1348 if ($cancel){ 1349 //when two elements we need a group 1350 $buttonarray=array(); 1351 $buttonarray[] = &$mform->createElement('submit', 'submitbutton', $submitlabel); 1352 $buttonarray[] = &$mform->createElement('cancel'); 1353 $mform->addGroup($buttonarray, 'buttonar', '', array(' '), false); 1354 $mform->closeHeaderBefore('buttonar'); 1355 } else { 1356 //no group needed 1357 $mform->addElement('submit', 'submitbutton', $submitlabel); 1358 $mform->closeHeaderBefore('submitbutton'); 1359 } 1360 } 1361 1362 /** 1363 * Adds an initialisation call for a standard JavaScript enhancement. 1364 * 1365 * This function is designed to add an initialisation call for a JavaScript 1366 * enhancement that should exist within javascript-static M.form.init_{enhancementname}. 1367 * 1368 * Current options: 1369 * - Selectboxes 1370 * - smartselect: Turns a nbsp indented select box into a custom drop down 1371 * control that supports multilevel and category selection. 1372 * $enhancement = 'smartselect'; 1373 * $options = array('selectablecategories' => true|false) 1374 * 1375 * @param string|element $element form element for which Javascript needs to be initalized 1376 * @param string $enhancement which init function should be called 1377 * @param array $options options passed to javascript 1378 * @param array $strings strings for javascript 1379 * @deprecated since Moodle 3.3 MDL-57471 1380 */ 1381 function init_javascript_enhancement($element, $enhancement, array $options=array(), array $strings=null) { 1382 debugging('$mform->init_javascript_enhancement() is deprecated and no longer does anything. '. 1383 'smartselect uses should be converted to the searchableselector form element.', DEBUG_DEVELOPER); 1384 } 1385 1386 /** 1387 * Returns a JS module definition for the mforms JS 1388 * 1389 * @return array 1390 */ 1391 public static function get_js_module() { 1392 global $CFG; 1393 return array( 1394 'name' => 'mform', 1395 'fullpath' => '/lib/form/form.js', 1396 'requires' => array('base', 'node') 1397 ); 1398 } 1399 1400 /** 1401 * Detects elements with missing setType() declerations. 1402 * 1403 * Finds elements in the form which should a PARAM_ type set and throws a 1404 * developer debug warning for any elements without it. This is to reduce the 1405 * risk of potential security issues by developers mistakenly forgetting to set 1406 * the type. 1407 * 1408 * @return void 1409 */ 1410 private function detectMissingSetType() { 1411 global $CFG; 1412 1413 if (!$CFG->debugdeveloper) { 1414 // Only for devs. 1415 return; 1416 } 1417 1418 $mform = $this->_form; 1419 foreach ($mform->_elements as $element) { 1420 $group = false; 1421 $elements = array($element); 1422 1423 if ($element->getType() == 'group') { 1424 $group = $element; 1425 $elements = $element->getElements(); 1426 } 1427 1428 foreach ($elements as $index => $element) { 1429 switch ($element->getType()) { 1430 case 'hidden': 1431 case 'text': 1432 case 'url': 1433 if ($group) { 1434 $name = $group->getElementName($index); 1435 } else { 1436 $name = $element->getName(); 1437 } 1438 $key = $name; 1439 $found = array_key_exists($key, $mform->_types); 1440 // For repeated elements we need to look for 1441 // the "main" type, not for the one present 1442 // on each repetition. All the stuff in formslib 1443 // (repeat_elements(), updateSubmission()... seems 1444 // to work that way. 1445 while (!$found && strrpos($key, '[') !== false) { 1446 $pos = strrpos($key, '['); 1447 $key = substr($key, 0, $pos); 1448 $found = array_key_exists($key, $mform->_types); 1449 } 1450 if (!$found) { 1451 debugging("Did you remember to call setType() for '$name'? ". 1452 'Defaulting to PARAM_RAW cleaning.', DEBUG_DEVELOPER); 1453 } 1454 break; 1455 } 1456 } 1457 } 1458 } 1459 1460 /** 1461 * Used by tests to simulate submitted form data submission from the user. 1462 * 1463 * For form fields where no data is submitted the default for that field as set by set_data or setDefault will be passed to 1464 * get_data. 1465 * 1466 * This method sets $_POST or $_GET and $_FILES with the data supplied. Our unit test code empties all these 1467 * global arrays after each test. 1468 * 1469 * @param array $simulatedsubmitteddata An associative array of form values (same format as $_POST). 1470 * @param array $simulatedsubmittedfiles An associative array of files uploaded (same format as $_FILES). Can be omitted. 1471 * @param string $method 'post' or 'get', defaults to 'post'. 1472 * @param null $formidentifier the default is to use the class name for this class but you may need to provide 1473 * a different value here for some forms that are used more than once on the 1474 * same page. 1475 */ 1476 public static function mock_submit($simulatedsubmitteddata, $simulatedsubmittedfiles = array(), $method = 'post', 1477 $formidentifier = null) { 1478 $_FILES = $simulatedsubmittedfiles; 1479 if ($formidentifier === null) { 1480 $formidentifier = get_called_class(); 1481 $formidentifier = str_replace('\\', '_', $formidentifier); // See MDL-56233 for more information. 1482 } 1483 $simulatedsubmitteddata['_qf__'.$formidentifier] = 1; 1484 $simulatedsubmitteddata['sesskey'] = sesskey(); 1485 if (strtolower($method) === 'get') { 1486 $_GET = $simulatedsubmitteddata; 1487 } else { 1488 $_POST = $simulatedsubmitteddata; 1489 } 1490 } 1491 1492 /** 1493 * Used by tests to simulate submitted form data submission via AJAX. 1494 * 1495 * For form fields where no data is submitted the default for that field as set by set_data or setDefault will be passed to 1496 * get_data. 1497 * 1498 * This method sets $_POST or $_GET and $_FILES with the data supplied. Our unit test code empties all these 1499 * global arrays after each test. 1500 * 1501 * @param array $simulatedsubmitteddata An associative array of form values (same format as $_POST). 1502 * @param array $simulatedsubmittedfiles An associative array of files uploaded (same format as $_FILES). Can be omitted. 1503 * @param string $method 'post' or 'get', defaults to 'post'. 1504 * @param null $formidentifier the default is to use the class name for this class but you may need to provide 1505 * a different value here for some forms that are used more than once on the 1506 * same page. 1507 * @return array array to pass to form constructor as $ajaxdata 1508 */ 1509 public static function mock_ajax_submit($simulatedsubmitteddata, $simulatedsubmittedfiles = array(), $method = 'post', 1510 $formidentifier = null) { 1511 $_FILES = $simulatedsubmittedfiles; 1512 if ($formidentifier === null) { 1513 $formidentifier = get_called_class(); 1514 $formidentifier = str_replace('\\', '_', $formidentifier); // See MDL-56233 for more information. 1515 } 1516 $simulatedsubmitteddata['_qf__'.$formidentifier] = 1; 1517 $simulatedsubmitteddata['sesskey'] = sesskey(); 1518 if (strtolower($method) === 'get') { 1519 $_GET = ['sesskey' => sesskey()]; 1520 } else { 1521 $_POST = ['sesskey' => sesskey()]; 1522 } 1523 return $simulatedsubmitteddata; 1524 } 1525 1526 /** 1527 * Used by tests to generate valid submit keys for moodle forms that are 1528 * submitted with ajax data. 1529 * 1530 * @throws \moodle_exception If called outside unit test environment 1531 * @param array $data Existing form data you wish to add the keys to. 1532 * @return array 1533 */ 1534 public static function mock_generate_submit_keys($data = []) { 1535 if (!defined('PHPUNIT_TEST') || !PHPUNIT_TEST) { 1536 throw new \moodle_exception("This function can only be used for unit testing."); 1537 } 1538 1539 $formidentifier = get_called_class(); 1540 $formidentifier = str_replace('\\', '_', $formidentifier); // See MDL-56233 for more information. 1541 $data['sesskey'] = sesskey(); 1542 $data['_qf__' . $formidentifier] = 1; 1543 1544 return $data; 1545 } 1546 1547 /** 1548 * Set display mode for the form when labels take full width of the form and above the elements even on big screens 1549 * 1550 * Useful for forms displayed inside modals or in narrow containers 1551 */ 1552 public function set_display_vertical() { 1553 $oldclass = $this->_form->getAttribute('class'); 1554 $this->_form->updateAttributes(array('class' => $oldclass . ' full-width-labels')); 1555 } 1556 1557 /** 1558 * Set the initial 'dirty' state of the form. 1559 * 1560 * @param bool $state 1561 * @since Moodle 3.7.1 1562 */ 1563 public function set_initial_dirty_state($state = false) { 1564 $this->_form->set_initial_dirty_state($state); 1565 } 1566 } 1567 1568 /** 1569 * MoodleQuickForm implementation 1570 * 1571 * You never extend this class directly. The class methods of this class are available from 1572 * the private $this->_form property on moodleform and its children. You generally only 1573 * call methods on this class from within abstract methods that you override on moodleform such 1574 * as definition and definition_after_data 1575 * 1576 * @package core_form 1577 * @category form 1578 * @copyright 2006 Jamie Pratt <me@jamiep.org> 1579 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 1580 */ 1581 class MoodleQuickForm extends HTML_QuickForm_DHTMLRulesTableless { 1582 /** @var array type (PARAM_INT, PARAM_TEXT etc) of element value */ 1583 var $_types = array(); 1584 1585 /** @var array dependent state for the element/'s */ 1586 var $_dependencies = array(); 1587 1588 /** 1589 * @var array elements that will become hidden based on another element 1590 */ 1591 protected $_hideifs = array(); 1592 1593 /** @var array Array of buttons that if pressed do not result in the processing of the form. */ 1594 var $_noSubmitButtons=array(); 1595 1596 /** @var array Array of buttons that if pressed do not result in the processing of the form. */ 1597 var $_cancelButtons=array(); 1598 1599 /** @var array Array whose keys are element names. If the key exists this is a advanced element */ 1600 var $_advancedElements = array(); 1601 1602 /** 1603 * Array whose keys are element names and values are the desired collapsible state. 1604 * True for collapsed, False for expanded. If not present, set to default in 1605 * {@link self::accept()}. 1606 * 1607 * @var array 1608 */ 1609 var $_collapsibleElements = array(); 1610 1611 /** 1612 * Whether to enable shortforms for this form 1613 * 1614 * @var boolean 1615 */ 1616 var $_disableShortforms = false; 1617 1618 /** @var bool whether to automatically initialise the form change detector this form. */ 1619 protected $_use_form_change_checker = true; 1620 1621 /** 1622 * The initial state of the dirty state. 1623 * 1624 * @var bool 1625 */ 1626 protected $_initial_form_dirty_state = false; 1627 1628 /** 1629 * The form name is derived from the class name of the wrapper minus the trailing form 1630 * It is a name with words joined by underscores whereas the id attribute is words joined by underscores. 1631 * @var string 1632 */ 1633 var $_formName = ''; 1634 1635 /** 1636 * String with the html for hidden params passed in as part of a moodle_url 1637 * object for the action. Output in the form. 1638 * @var string 1639 */ 1640 var $_pageparams = ''; 1641 1642 /** @var array names of new repeating elements that should not expect to find submitted data */ 1643 protected $_newrepeats = array(); 1644 1645 /** @var array $_ajaxformdata submitted form data when using mforms with ajax */ 1646 protected $_ajaxformdata; 1647 1648 /** 1649 * Whether the form contains any client-side validation or not. 1650 * @var bool 1651 */ 1652 protected $clientvalidation = false; 1653 1654 /** 1655 * Is this a 'disableIf' dependency ? 1656 */ 1657 const DEP_DISABLE = 0; 1658 1659 /** 1660 * Is this a 'hideIf' dependency? 1661 */ 1662 const DEP_HIDE = 1; 1663 1664 /** @var string request class HTML. */ 1665 protected $_reqHTML; 1666 1667 /** @var string advanced class HTML. */ 1668 protected $_advancedHTML; 1669 1670 /** 1671 * Class constructor - same parameters as HTML_QuickForm_DHTMLRulesTableless 1672 * 1673 * @staticvar int $formcounter counts number of forms 1674 * @param string $formName Form's name. 1675 * @param string $method Form's method defaults to 'POST' 1676 * @param string|moodle_url $action Form's action 1677 * @param string $target (optional)Form's target defaults to none 1678 * @param mixed $attributes (optional)Extra attributes for <form> tag 1679 * @param array $ajaxformdata Forms submitted via ajax, must pass their data here, instead of relying on _GET and _POST. 1680 */ 1681 public function __construct($formName, $method, $action, $target = '', $attributes = null, $ajaxformdata = null) { 1682 global $CFG, $OUTPUT; 1683 1684 static $formcounter = 1; 1685 1686 // TODO MDL-52313 Replace with the call to parent::__construct(). 1687 HTML_Common::__construct($attributes); 1688 $target = empty($target) ? array() : array('target' => $target); 1689 $this->_formName = $formName; 1690 if (is_a($action, 'moodle_url')){ 1691 $this->_pageparams = html_writer::input_hidden_params($action); 1692 $action = $action->out_omit_querystring(); 1693 } else { 1694 $this->_pageparams = ''; 1695 } 1696 // No 'name' atttribute for form in xhtml strict : 1697 $attributes = array('action' => $action, 'method' => $method, 'accept-charset' => 'utf-8') + $target; 1698 if (is_null($this->getAttribute('id'))) { 1699 // Append a random id, forms can be loaded in different requests using Fragments API. 1700 $attributes['id'] = 'mform' . $formcounter . '_' . random_string(); 1701 } 1702 $formcounter++; 1703 $this->updateAttributes($attributes); 1704 1705 // This is custom stuff for Moodle : 1706 $this->_ajaxformdata = $ajaxformdata; 1707 $oldclass= $this->getAttribute('class'); 1708 if (!empty($oldclass)){ 1709 $this->updateAttributes(array('class'=>$oldclass.' mform')); 1710 }else { 1711 $this->updateAttributes(array('class'=>'mform')); 1712 } 1713 $this->_reqHTML = '<span class="req">' . $OUTPUT->pix_icon('req', get_string('requiredelement', 'form')) . '</span>'; 1714 $this->_advancedHTML = '<span class="adv">' . $OUTPUT->pix_icon('adv', get_string('advancedelement', 'form')) . '</span>'; 1715 $this->setRequiredNote(get_string('somefieldsrequired', 'form', $OUTPUT->pix_icon('req', get_string('requiredelement', 'form')))); 1716 } 1717 1718 /** 1719 * Old syntax of class constructor. Deprecated in PHP7. 1720 * 1721 * @deprecated since Moodle 3.1 1722 */ 1723 public function MoodleQuickForm($formName, $method, $action, $target='', $attributes=null) { 1724 debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER); 1725 self::__construct($formName, $method, $action, $target, $attributes); 1726 } 1727 1728 /** 1729 * Use this method to indicate an element in a form is an advanced field. If items in a form 1730 * are marked as advanced then 'Hide/Show Advanced' buttons will automatically be displayed in the 1731 * form so the user can decide whether to display advanced form controls. 1732 * 1733 * If you set a header element to advanced then all elements it contains will also be set as advanced. 1734 * 1735 * @param string $elementName group or element name (not the element name of something inside a group). 1736 * @param bool $advanced default true sets the element to advanced. False removes advanced mark. 1737 */ 1738 function setAdvanced($elementName, $advanced = true) { 1739 if ($advanced){ 1740 $this->_advancedElements[$elementName]=''; 1741 } elseif (isset($this->_advancedElements[$elementName])) { 1742 unset($this->_advancedElements[$elementName]); 1743 } 1744 } 1745 1746 /** 1747 * Checks if a parameter was passed in the previous form submission 1748 * 1749 * @param string $name the name of the page parameter we want 1750 * @param mixed $default the default value to return if nothing is found 1751 * @param string $type expected type of parameter 1752 * @return mixed 1753 */ 1754 public function optional_param($name, $default, $type) { 1755 if (isset($this->_ajaxformdata[$name])) { 1756 return clean_param($this->_ajaxformdata[$name], $type); 1757 } else { 1758 return optional_param($name, $default, $type); 1759 } 1760 } 1761 1762 /** 1763 * Use this method to indicate that the fieldset should be shown as expanded. 1764 * The method is applicable to header elements only. 1765 * 1766 * @param string $headername header element name 1767 * @param boolean $expanded default true sets the element to expanded. False makes the element collapsed. 1768 * @param boolean $ignoreuserstate override the state regardless of the state it was on when 1769 * the form was submitted. 1770 * @return void 1771 */ 1772 function setExpanded($headername, $expanded = true, $ignoreuserstate = false) { 1773 if (empty($headername)) { 1774 return; 1775 } 1776 $element = $this->getElement($headername); 1777 if ($element->getType() != 'header') { 1778 debugging('Cannot use setExpanded on non-header elements', DEBUG_DEVELOPER); 1779 return; 1780 } 1781 if (!$headerid = $element->getAttribute('id')) { 1782 $element->_generateId(); 1783 $headerid = $element->getAttribute('id'); 1784 } 1785 if ($this->getElementType('mform_isexpanded_' . $headerid) === false) { 1786 // See if the form has been submitted already. 1787 $formexpanded = $this->optional_param('mform_isexpanded_' . $headerid, -1, PARAM_INT); 1788 if (!$ignoreuserstate && $formexpanded != -1) { 1789 // Override expanded state with the form variable. 1790 $expanded = $formexpanded; 1791 } 1792 // Create the form element for storing expanded state. 1793 $this->addElement('hidden', 'mform_isexpanded_' . $headerid); 1794 $this->setType('mform_isexpanded_' . $headerid, PARAM_INT); 1795 $this->setConstant('mform_isexpanded_' . $headerid, (int) $expanded); 1796 } 1797 $this->_collapsibleElements[$headername] = !$expanded; 1798 } 1799 1800 /** 1801 * Use this method to add show more/less status element required for passing 1802 * over the advanced elements visibility status on the form submission. 1803 * 1804 * @param string $headerName header element name. 1805 * @param boolean $showmore default false sets the advanced elements to be hidden. 1806 */ 1807 function addAdvancedStatusElement($headerid, $showmore=false){ 1808 // Add extra hidden element to store advanced items state for each section. 1809 if ($this->getElementType('mform_showmore_' . $headerid) === false) { 1810 // See if we the form has been submitted already. 1811 $formshowmore = $this->optional_param('mform_showmore_' . $headerid, -1, PARAM_INT); 1812 if (!$showmore && $formshowmore != -1) { 1813 // Override showmore state with the form variable. 1814 $showmore = $formshowmore; 1815 } 1816 // Create the form element for storing advanced items state. 1817 $this->addElement('hidden', 'mform_showmore_' . $headerid); 1818 $this->setType('mform_showmore_' . $headerid, PARAM_INT); 1819 $this->setConstant('mform_showmore_' . $headerid, (int)$showmore); 1820 } 1821 } 1822 1823 /** 1824 * This function has been deprecated. Show advanced has been replaced by 1825 * "Show more.../Show less..." in the shortforms javascript module. 1826 * 1827 * @deprecated since Moodle 2.5 1828 * @param bool $showadvancedNow if true will show advanced elements. 1829 */ 1830 function setShowAdvanced($showadvancedNow = null){ 1831 debugging('Call to deprecated function setShowAdvanced. See "Show more.../Show less..." in shortforms yui module.'); 1832 } 1833 1834 /** 1835 * This function has been deprecated. Show advanced has been replaced by 1836 * "Show more.../Show less..." in the shortforms javascript module. 1837 * 1838 * @deprecated since Moodle 2.5 1839 * @return bool (Always false) 1840 */ 1841 function getShowAdvanced(){ 1842 debugging('Call to deprecated function setShowAdvanced. See "Show more.../Show less..." in shortforms yui module.'); 1843 return false; 1844 } 1845 1846 /** 1847 * Use this method to indicate that the form will not be using shortforms. 1848 * 1849 * @param boolean $disable default true, controls if the shortforms are disabled. 1850 */ 1851 function setDisableShortforms ($disable = true) { 1852 $this->_disableShortforms = $disable; 1853 } 1854 1855 /** 1856 * Set the initial 'dirty' state of the form. 1857 * 1858 * @param bool $state 1859 * @since Moodle 3.7.1 1860 */ 1861 public function set_initial_dirty_state($state = false) { 1862 $this->_initial_form_dirty_state = $state; 1863 } 1864 1865 /** 1866 * Is the form currently set to dirty? 1867 * 1868 * @return boolean Initial dirty state. 1869 * @since Moodle 3.7.1 1870 */ 1871 public function is_dirty() { 1872 return $this->_initial_form_dirty_state; 1873 } 1874 1875 /** 1876 * Call this method if you don't want the formchangechecker JavaScript to be 1877 * automatically initialised for this form. 1878 */ 1879 public function disable_form_change_checker() { 1880 $this->_use_form_change_checker = false; 1881 } 1882 1883 /** 1884 * If you have called {@link disable_form_change_checker()} then you can use 1885 * this method to re-enable it. It is enabled by default, so normally you don't 1886 * need to call this. 1887 */ 1888 public function enable_form_change_checker() { 1889 $this->_use_form_change_checker = true; 1890 } 1891 1892 /** 1893 * @return bool whether this form should automatically initialise 1894 * formchangechecker for itself. 1895 */ 1896 public function is_form_change_checker_enabled() { 1897 return $this->_use_form_change_checker; 1898 } 1899 1900 /** 1901 * Accepts a renderer 1902 * 1903 * @param HTML_QuickForm_Renderer $renderer An HTML_QuickForm_Renderer object 1904 */ 1905 function accept(&$renderer) { 1906 if (method_exists($renderer, 'setAdvancedElements')){ 1907 //Check for visible fieldsets where all elements are advanced 1908 //and mark these headers as advanced as well. 1909 //Also mark all elements in a advanced header as advanced. 1910 $stopFields = $renderer->getStopFieldSetElements(); 1911 $lastHeader = null; 1912 $lastHeaderAdvanced = false; 1913 $anyAdvanced = false; 1914 $anyError = false; 1915 foreach (array_keys($this->_elements) as $elementIndex){ 1916 $element =& $this->_elements[$elementIndex]; 1917 1918 // if closing header and any contained element was advanced then mark it as advanced 1919 if ($element->getType()=='header' || in_array($element->getName(), $stopFields)){ 1920 if ($anyAdvanced && !is_null($lastHeader)) { 1921 $lastHeader->_generateId(); 1922 $this->setAdvanced($lastHeader->getName()); 1923 $this->addAdvancedStatusElement($lastHeader->getAttribute('id'), $anyError); 1924 } 1925 $lastHeaderAdvanced = false; 1926 unset($lastHeader); 1927 $lastHeader = null; 1928 } elseif ($lastHeaderAdvanced) { 1929 $this->setAdvanced($element->getName()); 1930 } 1931 1932 if ($element->getType()=='header'){ 1933 $lastHeader =& $element; 1934 $anyAdvanced = false; 1935 $anyError = false; 1936 $lastHeaderAdvanced = isset($this->_advancedElements[$element->getName()]); 1937 } elseif (isset($this->_advancedElements[$element->getName()])){ 1938 $anyAdvanced = true; 1939 if (isset($this->_errors[$element->getName()])) { 1940 $anyError = true; 1941 } 1942 } 1943 } 1944 // the last header may not be closed yet... 1945 if ($anyAdvanced && !is_null($lastHeader)){ 1946 $this->setAdvanced($lastHeader->getName()); 1947 $lastHeader->_generateId(); 1948 $this->addAdvancedStatusElement($lastHeader->getAttribute('id'), $anyError); 1949 } 1950 $renderer->setAdvancedElements($this->_advancedElements); 1951 } 1952 if (method_exists($renderer, 'setCollapsibleElements') && !$this->_disableShortforms) { 1953 1954 // Count the number of sections. 1955 $headerscount = 0; 1956 foreach (array_keys($this->_elements) as $elementIndex){ 1957 $element =& $this->_elements[$elementIndex]; 1958 if ($element->getType() == 'header') { 1959 $headerscount++; 1960 } 1961 } 1962 1963 $anyrequiredorerror = false; 1964 $headercounter = 0; 1965 $headername = null; 1966 foreach (array_keys($this->_elements) as $elementIndex){ 1967 $element =& $this->_elements[$elementIndex]; 1968 1969 if ($element->getType() == 'header') { 1970 $headercounter++; 1971 $element->_generateId(); 1972 $headername = $element->getName(); 1973 $anyrequiredorerror = false; 1974 } else if (in_array($element->getName(), $this->_required) || isset($this->_errors[$element->getName()])) { 1975 $anyrequiredorerror = true; 1976 } else { 1977 // Do not reset $anyrequiredorerror to false because we do not want any other element 1978 // in this header (fieldset) to possibly revert the state given. 1979 } 1980 1981 if ($element->getType() == 'header') { 1982 if ($headercounter === 1 && !isset($this->_collapsibleElements[$headername])) { 1983 // By default the first section is always expanded, except if a state has already been set. 1984 $this->setExpanded($headername, true); 1985 } else if (($headercounter === 2 && $headerscount === 2) && !isset($this->_collapsibleElements[$headername])) { 1986 // The second section is always expanded if the form only contains 2 sections), 1987 // except if a state has already been set. 1988 $this->setExpanded($headername, true); 1989 } 1990 } else if ($anyrequiredorerror) { 1991 // If any error or required field are present within the header, we need to expand it. 1992 $this->setExpanded($headername, true, true); 1993 } else if (!isset($this->_collapsibleElements[$headername])) { 1994 // Define element as collapsed by default. 1995 $this->setExpanded($headername, false); 1996 } 1997 } 1998 1999 // Pass the array to renderer object. 2000 $renderer->setCollapsibleElements($this->_collapsibleElements); 2001 } 2002 parent::accept($renderer); 2003 } 2004 2005 /** 2006 * Adds one or more element names that indicate the end of a fieldset 2007 * 2008 * @param string $elementName name of the element 2009 */ 2010 function closeHeaderBefore($elementName){ 2011 $renderer =& $this->defaultRenderer(); 2012 $renderer->addStopFieldsetElements($elementName); 2013 } 2014 2015 /** 2016 * Set an element to be forced to flow LTR. 2017 * 2018 * The element must exist and support this functionality. Also note that 2019 * when setting the type of a field (@link self::setType} we try to guess the 2020 * whether the field should be force to LTR or not. Make sure you're always 2021 * calling this method last. 2022 * 2023 * @param string $elementname The element name. 2024 * @param bool $value When false, disables force LTR, else enables it. 2025 */ 2026 public function setForceLtr($elementname, $value = true) { 2027 $this->getElement($elementname)->set_force_ltr($value); 2028 } 2029 2030 /** 2031 * Should be used for all elements of a form except for select, radio and checkboxes which 2032 * clean their own data. 2033 * 2034 * @param string $elementname 2035 * @param string $paramtype defines type of data contained in element. Use the constants PARAM_*. 2036 * {@link lib/moodlelib.php} for defined parameter types 2037 */ 2038 function setType($elementname, $paramtype) { 2039 $this->_types[$elementname] = $paramtype; 2040 2041 // This will not always get it right, but it should be accurate in most cases. 2042 // When inaccurate use setForceLtr(). 2043 if (!is_rtl_compatible($paramtype) 2044 && $this->elementExists($elementname) 2045 && ($element =& $this->getElement($elementname)) 2046 && method_exists($element, 'set_force_ltr')) { 2047 2048 $element->set_force_ltr(true); 2049 } 2050 } 2051 2052 /** 2053 * This can be used to set several types at once. 2054 * 2055 * @param array $paramtypes types of parameters. 2056 * @see MoodleQuickForm::setType 2057 */ 2058 function setTypes($paramtypes) { 2059 foreach ($paramtypes as $elementname => $paramtype) { 2060 $this->setType($elementname, $paramtype); 2061 } 2062 } 2063 2064 /** 2065 * Return the type(s) to use to clean an element. 2066 * 2067 * In the case where the element has an array as a value, we will try to obtain a 2068 * type defined for that specific key, and recursively until done. 2069 * 2070 * This method does not work reverse, you cannot pass a nested element and hoping to 2071 * fallback on the clean type of a parent. This method intends to be used with the 2072 * main element, which will generate child types if needed, not the other way around. 2073 * 2074 * Example scenario: 2075 * 2076 * You have defined a new repeated element containing a text field called 'foo'. 2077 * By default there will always be 2 occurence of 'foo' in the form. Even though 2078 * you've set the type on 'foo' to be PARAM_INT, for some obscure reason, you want 2079 * the first value of 'foo', to be PARAM_FLOAT, which you set using setType: 2080 * $mform->setType('foo[0]', PARAM_FLOAT). 2081 * 2082 * Now if you call this method passing 'foo', along with the submitted values of 'foo': 2083 * array(0 => '1.23', 1 => '10'), you will get an array telling you that the key 0 is a 2084 * FLOAT and 1 is an INT. If you had passed 'foo[1]', along with its value '10', you would 2085 * get the default clean type returned (param $default). 2086 * 2087 * @param string $elementname name of the element. 2088 * @param mixed $value value that should be cleaned. 2089 * @param int $default default constant value to be returned (PARAM_...) 2090 * @return string|array constant value or array of constant values (PARAM_...) 2091 */ 2092 public function getCleanType($elementname, $value, $default = PARAM_RAW) { 2093 $type = $default; 2094 if (array_key_exists($elementname, $this->_types)) { 2095 $type = $this->_types[$elementname]; 2096 } 2097 if (is_array($value)) { 2098 $default = $type; 2099 $type = array(); 2100 foreach ($value as $subkey => $subvalue) { 2101 $typekey = "$elementname" . "[$subkey]"; 2102 if (array_key_exists($typekey, $this->_types)) { 2103 $subtype = $this->_types[$typekey]; 2104 } else { 2105 $subtype = $default; 2106 } 2107 if (is_array($subvalue)) { 2108 $type[$subkey] = $this->getCleanType($typekey, $subvalue, $subtype); 2109 } else { 2110 $type[$subkey] = $subtype; 2111 } 2112 } 2113 } 2114 return $type; 2115 } 2116 2117 /** 2118 * Return the cleaned value using the passed type(s). 2119 * 2120 * @param mixed $value value that has to be cleaned. 2121 * @param int|array $type constant value to use to clean (PARAM_...), typically returned by {@link self::getCleanType()}. 2122 * @return mixed cleaned up value. 2123 */ 2124 public function getCleanedValue($value, $type) { 2125 if (is_array($type) && is_array($value)) { 2126 foreach ($type as $key => $param) { 2127 $value[$key] = $this->getCleanedValue($value[$key], $param); 2128 } 2129 } else if (!is_array($type) && !is_array($value)) { 2130 $value = clean_param($value, $type); 2131 } else if (!is_array($type) && is_array($value)) { 2132 $value = clean_param_array($value, $type, true); 2133 } else { 2134 throw new coding_exception('Unexpected type or value received in MoodleQuickForm::getCleanedValue()'); 2135 } 2136 return $value; 2137 } 2138 2139 /** 2140 * Updates submitted values 2141 * 2142 * @param array $submission submitted values 2143 * @param array $files list of files 2144 */ 2145 function updateSubmission($submission, $files) { 2146 $this->_flagSubmitted = false; 2147 2148 if (empty($submission)) { 2149 $this->_submitValues = array(); 2150 } else { 2151 foreach ($submission as $key => $s) { 2152 $type = $this->getCleanType($key, $s); 2153 $submission[$key] = $this->getCleanedValue($s, $type); 2154 } 2155 $this->_submitValues = $submission; 2156 $this->_flagSubmitted = true; 2157 } 2158 2159 if (empty($files)) { 2160 $this->_submitFiles = array(); 2161 } else { 2162 $this->_submitFiles = $files; 2163 $this->_flagSubmitted = true; 2164 } 2165 2166 // need to tell all elements that they need to update their value attribute. 2167 foreach (array_keys($this->_elements) as $key) { 2168 $this->_elements[$key]->onQuickFormEvent('updateValue', null, $this); 2169 } 2170 } 2171 2172 /** 2173 * Returns HTML for required elements 2174 * 2175 * @return string 2176 */ 2177 function getReqHTML(){ 2178 return $this->_reqHTML; 2179 } 2180 2181 /** 2182 * Returns HTML for advanced elements 2183 * 2184 * @return string 2185 */ 2186 function getAdvancedHTML(){ 2187 return $this->_advancedHTML; 2188 } 2189 2190 /** 2191 * Initializes a default form value. Used to specify the default for a new entry where 2192 * no data is loaded in using moodleform::set_data() 2193 * 2194 * note: $slashed param removed 2195 * 2196 * @param string $elementName element name 2197 * @param mixed $defaultValue values for that element name 2198 */ 2199 function setDefault($elementName, $defaultValue){ 2200 $this->setDefaults(array($elementName=>$defaultValue)); 2201 } 2202 2203 /** 2204 * Add a help button to element, only one button per element is allowed. 2205 * 2206 * This is new, simplified and preferable method of setting a help icon on form elements. 2207 * It uses the new $OUTPUT->help_icon(). 2208 * 2209 * Typically, you will provide the same identifier and the component as you have used for the 2210 * label of the element. The string identifier with the _help suffix added is then used 2211 * as the help string. 2212 * 2213 * There has to be two strings defined: 2214 * 1/ get_string($identifier, $component) - the title of the help page 2215 * 2/ get_string($identifier.'_help', $component) - the actual help page text 2216 * 2217 * @since Moodle 2.0 2218 * @param string $elementname name of the element to add the item to 2219 * @param string $identifier help string identifier without _help suffix 2220 * @param string $component component name to look the help string in 2221 * @param string $linktext optional text to display next to the icon 2222 * @param bool $suppresscheck set to true if the element may not exist 2223 */ 2224 function addHelpButton($elementname, $identifier, $component = 'moodle', $linktext = '', $suppresscheck = false) { 2225 global $OUTPUT; 2226 if (array_key_exists($elementname, $this->_elementIndex)) { 2227 $element = $this->_elements[$this->_elementIndex[$elementname]]; 2228 $element->_helpbutton = $OUTPUT->help_icon($identifier, $component, $linktext); 2229 } else if (!$suppresscheck) { 2230 debugging(get_string('nonexistentformelements', 'form', $elementname)); 2231 } 2232 } 2233 2234 /** 2235 * Set constant value not overridden by _POST or _GET 2236 * note: this does not work for complex names with [] :-( 2237 * 2238 * @param string $elname name of element 2239 * @param mixed $value 2240 */ 2241 function setConstant($elname, $value) { 2242 $this->_constantValues = HTML_QuickForm::arrayMerge($this->_constantValues, array($elname=>$value)); 2243 $element =& $this->getElement($elname); 2244 $element->onQuickFormEvent('updateValue', null, $this); 2245 } 2246 2247 /** 2248 * export submitted values 2249 * 2250 * @param string $elementList list of elements in form 2251 * @return array 2252 */ 2253 function exportValues($elementList = null){ 2254 $unfiltered = array(); 2255 if (null === $elementList) { 2256 // iterate over all elements, calling their exportValue() methods 2257 foreach (array_keys($this->_elements) as $key) { 2258 if ($this->_elements[$key]->isFrozen() && !$this->_elements[$key]->_persistantFreeze) { 2259 $value = ''; 2260 if (isset($this->_elements[$key]->_attributes['name'])) { 2261 $varname = $this->_elements[$key]->_attributes['name']; 2262 // If we have a default value then export it. 2263 if (isset($this->_defaultValues[$varname])) { 2264 $value = $this->prepare_fixed_value($varname, $this->_defaultValues[$varname]); 2265 } 2266 } 2267 } else { 2268 $value = $this->_elements[$key]->exportValue($this->_submitValues, true); 2269 } 2270 2271 if (is_array($value)) { 2272 // This shit throws a bogus warning in PHP 4.3.x 2273 $unfiltered = HTML_QuickForm::arrayMerge($unfiltered, $value); 2274 } 2275 } 2276 } else { 2277 if (!is_array($elementList)) { 2278 $elementList = array_map('trim', explode(',', $elementList)); 2279 } 2280 foreach ($elementList as $elementName) { 2281 $value = $this->exportValue($elementName); 2282 if ((new PEAR())->isError($value)) { 2283 return $value; 2284 } 2285 //oh, stock QuickFOrm was returning array of arrays! 2286 $unfiltered = HTML_QuickForm::arrayMerge($unfiltered, $value); 2287 } 2288 } 2289 2290 if (is_array($this->_constantValues)) { 2291 $unfiltered = HTML_QuickForm::arrayMerge($unfiltered, $this->_constantValues); 2292 } 2293 return $unfiltered; 2294 } 2295 2296 /** 2297 * This is a bit of a hack, and it duplicates the code in 2298 * HTML_QuickForm_element::_prepareValue, but I could not think of a way or 2299 * reliably calling that code. (Think about date selectors, for example.) 2300 * @param string $name the element name. 2301 * @param mixed $value the fixed value to set. 2302 * @return mixed the appropriate array to add to the $unfiltered array. 2303 */ 2304 protected function prepare_fixed_value($name, $value) { 2305 if (null === $value) { 2306 return null; 2307 } else { 2308 if (!strpos($name, '[')) { 2309 return array($name => $value); 2310 } else { 2311 $valueAry = array(); 2312 $myIndex = "['" . str_replace(array(']', '['), array('', "']['"), $name) . "']"; 2313 eval("\$valueAry$myIndex = \$value;"); 2314 return $valueAry; 2315 } 2316 } 2317 } 2318 2319 /** 2320 * Adds a validation rule for the given field 2321 * 2322 * If the element is in fact a group, it will be considered as a whole. 2323 * To validate grouped elements as separated entities, 2324 * use addGroupRule instead of addRule. 2325 * 2326 * @param string $element Form element name 2327 * @param string|null $message Message to display for invalid data 2328 * @param string $type Rule type, use getRegisteredRules() to get types 2329 * @param mixed $format (optional)Required for extra rule data 2330 * @param string $validation (optional)Where to perform validation: "server", "client" 2331 * @param bool $reset Client-side validation: reset the form element to its original value if there is an error? 2332 * @param bool $force Force the rule to be applied, even if the target form element does not exist 2333 */ 2334 function addRule($element, $message, $type, $format=null, $validation='server', $reset = false, $force = false) 2335 { 2336 parent::addRule($element, $message, $type, $format, $validation, $reset, $force); 2337 if ($validation == 'client') { 2338 $this->clientvalidation = true; 2339 } 2340 2341 } 2342 2343 /** 2344 * Adds a validation rule for the given group of elements 2345 * 2346 * Only groups with a name can be assigned a validation rule 2347 * Use addGroupRule when you need to validate elements inside the group. 2348 * Use addRule if you need to validate the group as a whole. In this case, 2349 * the same rule will be applied to all elements in the group. 2350 * Use addRule if you need to validate the group against a function. 2351 * 2352 * @param string $group Form group name 2353 * @param array|string $arg1 Array for multiple elements or error message string for one element 2354 * @param string $type (optional)Rule type use getRegisteredRules() to get types 2355 * @param string $format (optional)Required for extra rule data 2356 * @param int $howmany (optional)How many valid elements should be in the group 2357 * @param string $validation (optional)Where to perform validation: "server", "client" 2358 * @param bool $reset Client-side: whether to reset the element's value to its original state if validation failed. 2359 */ 2360 function addGroupRule($group, $arg1, $type='', $format=null, $howmany=0, $validation = 'server', $reset = false) 2361 { 2362 parent::addGroupRule($group, $arg1, $type, $format, $howmany, $validation, $reset); 2363 if (is_array($arg1)) { 2364 foreach ($arg1 as $rules) { 2365 foreach ($rules as $rule) { 2366 $validation = (isset($rule[3]) && 'client' == $rule[3])? 'client': 'server'; 2367 if ($validation == 'client') { 2368 $this->clientvalidation = true; 2369 } 2370 } 2371 } 2372 } elseif (is_string($arg1)) { 2373 if ($validation == 'client') { 2374 $this->clientvalidation = true; 2375 } 2376 } 2377 } 2378 2379 /** 2380 * Returns the client side validation script 2381 * 2382 * The code here was copied from HTML_QuickForm_DHTMLRulesTableless who copied it from HTML_QuickForm 2383 * and slightly modified to run rules per-element 2384 * Needed to override this because of an error with client side validation of grouped elements. 2385 * 2386 * @return string Javascript to perform validation, empty string if no 'client' rules were added 2387 */ 2388 function getValidationScript() 2389 { 2390 global $PAGE; 2391 2392 if (empty($this->_rules) || $this->clientvalidation === false) { 2393 return ''; 2394 } 2395 2396 include_once('HTML/QuickForm/RuleRegistry.php'); 2397 $registry =& HTML_QuickForm_RuleRegistry::singleton(); 2398 $test = array(); 2399 $js_escape = array( 2400 "\r" => '\r', 2401 "\n" => '\n', 2402 "\t" => '\t', 2403 "'" => "\\'", 2404 '"' => '\"', 2405 '\\' => '\\\\' 2406 ); 2407 2408 foreach ($this->_rules as $elementName => $rules) { 2409 foreach ($rules as $rule) { 2410 if ('client' == $rule['validation']) { 2411 unset($element); //TODO: find out how to properly initialize it 2412 2413 $dependent = isset($rule['dependent']) && is_array($rule['dependent']); 2414 $rule['message'] = strtr($rule['message'], $js_escape); 2415 2416 if (isset($rule['group'])) { 2417 $group =& $this->getElement($rule['group']); 2418 // No JavaScript validation for frozen elements 2419 if ($group->isFrozen()) { 2420 continue 2; 2421 } 2422 $elements =& $group->getElements(); 2423 foreach (array_keys($elements) as $key) { 2424 if ($elementName == $group->getElementName($key)) { 2425 $element =& $elements[$key]; 2426 break; 2427 } 2428 } 2429 } elseif ($dependent) { 2430 $element = array(); 2431 $element[] =& $this->getElement($elementName); 2432 foreach ($rule['dependent'] as $elName) { 2433 $element[] =& $this->getElement($elName); 2434 } 2435 } else { 2436 $element =& $this->getElement($elementName); 2437 } 2438 // No JavaScript validation for frozen elements 2439 if (is_object($element) && $element->isFrozen()) { 2440 continue 2; 2441 } elseif (is_array($element)) { 2442 foreach (array_keys($element) as $key) { 2443 if ($element[$key]->isFrozen()) { 2444 continue 3; 2445 } 2446 } 2447 } 2448 //for editor element, [text] is appended to the name. 2449 $fullelementname = $elementName; 2450 if (is_object($element) && $element->getType() == 'editor') { 2451 if ($element->getType() == 'editor') { 2452 $fullelementname .= '[text]'; 2453 // Add format to rule as moodleform check which format is supported by browser 2454 // it is not set anywhere... So small hack to make sure we pass it down to quickform. 2455 if (is_null($rule['format'])) { 2456 $rule['format'] = $element->getFormat(); 2457 } 2458 } 2459 } 2460 // Fix for bug displaying errors for elements in a group 2461 $test[$fullelementname][0][] = $registry->getValidationScript($element, $fullelementname, $rule); 2462 $test[$fullelementname][1]=$element; 2463 //end of fix 2464 } 2465 } 2466 } 2467 2468 // Fix for MDL-9524. If you don't do this, then $element may be left as a reference to one of the fields in 2469 // the form, and then that form field gets corrupted by the code that follows. 2470 unset($element); 2471 2472 $js = ' 2473 2474 require([ 2475 "core_form/events", 2476 "jquery", 2477 ], function( 2478 FormEvents, 2479 $ 2480 ) { 2481 2482 function qf_errorHandler(element, _qfMsg, escapedName) { 2483 const event = FormEvents.notifyFieldValidationFailure(element, _qfMsg); 2484 if (event.defaultPrevented) { 2485 return _qfMsg == \'\'; 2486 } else { 2487 // Legacy mforms. 2488 var div = element.parentNode; 2489 2490 if ((div == undefined) || (element.name == undefined)) { 2491 // No checking can be done for undefined elements so let server handle it. 2492 return true; 2493 } 2494 2495 if (_qfMsg != \'\') { 2496 var errorSpan = document.getElementById(\'id_error_\' + escapedName); 2497 if (!errorSpan) { 2498 errorSpan = document.createElement("span"); 2499 errorSpan.id = \'id_error_\' + escapedName; 2500 errorSpan.className = "error"; 2501 element.parentNode.insertBefore(errorSpan, element.parentNode.firstChild); 2502 document.getElementById(errorSpan.id).setAttribute(\'TabIndex\', \'0\'); 2503 document.getElementById(errorSpan.id).focus(); 2504 } 2505 2506 while (errorSpan.firstChild) { 2507 errorSpan.removeChild(errorSpan.firstChild); 2508 } 2509 2510 errorSpan.appendChild(document.createTextNode(_qfMsg.substring(3))); 2511 2512 if (div.className.substr(div.className.length - 6, 6) != " error" 2513 && div.className != "error") { 2514 div.className += " error"; 2515 linebreak = document.createElement("br"); 2516 linebreak.className = "error"; 2517 linebreak.id = \'id_error_break_\' + escapedName; 2518 errorSpan.parentNode.insertBefore(linebreak, errorSpan.nextSibling); 2519 } 2520 2521 return false; 2522 } else { 2523 var errorSpan = document.getElementById(\'id_error_\' + escapedName); 2524 if (errorSpan) { 2525 errorSpan.parentNode.removeChild(errorSpan); 2526 } 2527 var linebreak = document.getElementById(\'id_error_break_\' + escapedName); 2528 if (linebreak) { 2529 linebreak.parentNode.removeChild(linebreak); 2530 } 2531 2532 if (div.className.substr(div.className.length - 6, 6) == " error") { 2533 div.className = div.className.substr(0, div.className.length - 6); 2534 } else if (div.className == "error") { 2535 div.className = ""; 2536 } 2537 2538 return true; 2539 } // End if. 2540 } // End if. 2541 } // End function. 2542 '; 2543 $validateJS = ''; 2544 foreach ($test as $elementName => $jsandelement) { 2545 // Fix for bug displaying errors for elements in a group 2546 //unset($element); 2547 list($jsArr,$element)=$jsandelement; 2548 //end of fix 2549 $escapedElementName = preg_replace_callback( 2550 '/[_\[\]-]/', 2551 function($matches) { 2552 return sprintf("_%2x", ord($matches[0])); 2553 }, 2554 $elementName); 2555 $valFunc = 'validate_' . $this->_formName . '_' . $escapedElementName . '(ev.target, \''.$escapedElementName.'\')'; 2556 2557 if (!is_array($element)) { 2558 $element = [$element]; 2559 } 2560 foreach ($element as $elem) { 2561 if (key_exists('id', $elem->_attributes)) { 2562 $js .= ' 2563 function validate_' . $this->_formName . '_' . $escapedElementName . '(element, escapedName) { 2564 if (undefined == element) { 2565 //required element was not found, then let form be submitted without client side validation 2566 return true; 2567 } 2568 var value = \'\'; 2569 var errFlag = new Array(); 2570 var _qfGroups = {}; 2571 var _qfMsg = \'\'; 2572 var frm = element.parentNode; 2573 if ((undefined != element.name) && (frm != undefined)) { 2574 while (frm && frm.nodeName.toUpperCase() != "FORM") { 2575 frm = frm.parentNode; 2576 } 2577 ' . join("\n", $jsArr) . ' 2578 return qf_errorHandler(element, _qfMsg, escapedName); 2579 } else { 2580 //element name should be defined else error msg will not be displayed. 2581 return true; 2582 } 2583 } 2584 2585 document.getElementById(\'' . $elem->_attributes['id'] . '\').addEventListener(\'blur\', function(ev) { 2586 ' . $valFunc . ' 2587 }); 2588 document.getElementById(\'' . $elem->_attributes['id'] . '\').addEventListener(\'change\', function(ev) { 2589 ' . $valFunc . ' 2590 }); 2591 '; 2592 } 2593 } 2594 // This handles both randomised (MDL-65217) and non-randomised IDs. 2595 $errorid = preg_replace('/^id_/', 'id_error_', $elem->_attributes['id']); 2596 $validateJS .= ' 2597 ret = validate_' . $this->_formName . '_' . $escapedElementName.'(frm.elements[\''.$elementName.'\'], \''.$escapedElementName.'\') && ret; 2598 if (!ret && !first_focus) { 2599 first_focus = true; 2600 const element = document.getElementById("' . $errorid . '"); 2601 if (element) { 2602 FormEvents.notifyFormError(element); 2603 element.focus(); 2604 } 2605 } 2606 '; 2607 2608 // Fix for bug displaying errors for elements in a group 2609 //unset($element); 2610 //$element =& $this->getElement($elementName); 2611 //end of fix 2612 //$onBlur = $element->getAttribute('onBlur'); 2613 //$onChange = $element->getAttribute('onChange'); 2614 //$element->updateAttributes(array('onBlur' => $onBlur . $valFunc, 2615 //'onChange' => $onChange . $valFunc)); 2616 } 2617 // do not rely on frm function parameter, because htmlarea breaks it when overloading the onsubmit method 2618 $js .= ' 2619 2620 function validate_' . $this->_formName . '() { 2621 if (skipClientValidation) { 2622 return true; 2623 } 2624 var ret = true; 2625 2626 var frm = document.getElementById(\''. $this->_attributes['id'] .'\') 2627 var first_focus = false; 2628 ' . $validateJS . '; 2629 return ret; 2630 } 2631 2632 var form = document.getElementById(\'' . $this->_attributes['id'] . '\').closest(\'form\'); 2633 form.addEventListener(FormEvents.eventTypes.formSubmittedByJavascript, () => { 2634 try { 2635 var myValidator = validate_' . $this->_formName . '; 2636 } catch(e) { 2637 return; 2638 } 2639 if (myValidator) { 2640 myValidator(); 2641 } 2642 }); 2643 2644 document.getElementById(\'' . $this->_attributes['id'] . '\').addEventListener(\'submit\', function(ev) { 2645 try { 2646 var myValidator = validate_' . $this->_formName . '; 2647 } catch(e) { 2648 return true; 2649 } 2650 if (typeof window.tinyMCE !== \'undefined\') { 2651 window.tinyMCE.triggerSave(); 2652 } 2653 if (!myValidator()) { 2654 ev.preventDefault(); 2655 } 2656 }); 2657 2658 }); 2659 '; 2660 2661 $PAGE->requires->js_amd_inline($js); 2662 2663 // Global variable used to skip the client validation. 2664 return html_writer::tag('script', 'var skipClientValidation = false;'); 2665 } // end func getValidationScript 2666 2667 /** 2668 * Sets default error message 2669 */ 2670 function _setDefaultRuleMessages(){ 2671 foreach ($this->_rules as $field => $rulesarr){ 2672 foreach ($rulesarr as $key => $rule){ 2673 if ($rule['message']===null){ 2674 $a=new stdClass(); 2675 $a->format=$rule['format']; 2676 $str=get_string('err_'.$rule['type'], 'form', $a); 2677 if (strpos($str, '[[')!==0){ 2678 $this->_rules[$field][$key]['message']=$str; 2679 } 2680 } 2681 } 2682 } 2683 } 2684 2685 /** 2686 * Get list of attributes which have dependencies 2687 * 2688 * @return array 2689 */ 2690 function getLockOptionObject(){ 2691 $result = array(); 2692 foreach ($this->_dependencies as $dependentOn => $conditions){ 2693 $result[$dependentOn] = array(); 2694 foreach ($conditions as $condition=>$values) { 2695 $result[$dependentOn][$condition] = array(); 2696 foreach ($values as $value=>$dependents) { 2697 $result[$dependentOn][$condition][$value][self::DEP_DISABLE] = array(); 2698 foreach ($dependents as $dependent) { 2699 $elements = $this->_getElNamesRecursive($dependent); 2700 if (empty($elements)) { 2701 // probably element inside of some group 2702 $elements = array($dependent); 2703 } 2704 foreach($elements as $element) { 2705 if ($element == $dependentOn) { 2706 continue; 2707 } 2708 $result[$dependentOn][$condition][$value][self::DEP_DISABLE][] = $element; 2709 } 2710 } 2711 } 2712 } 2713 } 2714 foreach ($this->_hideifs as $dependenton => $conditions) { 2715 if (!isset($result[$dependenton])) { 2716 $result[$dependenton] = array(); 2717 } 2718 foreach ($conditions as $condition => $values) { 2719 if (!isset($result[$dependenton][$condition])) { 2720 $result[$dependenton][$condition] = array(); 2721 } 2722 foreach ($values as $value => $dependents) { 2723 $result[$dependenton][$condition][$value][self::DEP_HIDE] = array(); 2724 foreach ($dependents as $dependent) { 2725 $elements = $this->_getElNamesRecursive($dependent); 2726 if (!in_array($dependent, $elements)) { 2727 // Always want to hide the main element, even if it contains sub-elements as well. 2728 $elements[] = $dependent; 2729 } 2730 foreach ($elements as $element) { 2731 if ($element == $dependenton) { 2732 continue; 2733 } 2734 $result[$dependenton][$condition][$value][self::DEP_HIDE][] = $element; 2735 } 2736 } 2737 } 2738 } 2739 } 2740 return array($this->getAttribute('id'), $result); 2741 } 2742 2743 /** 2744 * Get names of element or elements in a group. 2745 * 2746 * @param HTML_QuickForm_group|element $element element group or element object 2747 * @return array 2748 */ 2749 function _getElNamesRecursive($element) { 2750 if (is_string($element)) { 2751 if (!$this->elementExists($element)) { 2752 return array(); 2753 } 2754 $element = $this->getElement($element); 2755 } 2756 2757 if (is_a($element, 'HTML_QuickForm_group')) { 2758 $elsInGroup = $element->getElements(); 2759 $elNames = array(); 2760 foreach ($elsInGroup as $elInGroup){ 2761 if (is_a($elInGroup, 'HTML_QuickForm_group')) { 2762 // Groups nested in groups: append the group name to the element and then change it back. 2763 // We will be appending group name again in MoodleQuickForm_group::export_for_template(). 2764 $oldname = $elInGroup->getName(); 2765 if ($element->_appendName) { 2766 $elInGroup->setName($element->getName() . '[' . $oldname . ']'); 2767 } 2768 $elNames = array_merge($elNames, $this->_getElNamesRecursive($elInGroup)); 2769 $elInGroup->setName($oldname); 2770 } else { 2771 $elNames[] = $element->getElementName($elInGroup->getName()); 2772 } 2773 } 2774 2775 } else if (is_a($element, 'HTML_QuickForm_header')) { 2776 return array(); 2777 2778 } else if (is_a($element, 'HTML_QuickForm_hidden')) { 2779 return array(); 2780 2781 } else if (method_exists($element, 'getPrivateName') && 2782 !($element instanceof HTML_QuickForm_advcheckbox)) { 2783 // The advcheckbox element implements a method called getPrivateName, 2784 // but in a way that is not compatible with the generic API, so we 2785 // have to explicitly exclude it. 2786 return array($element->getPrivateName()); 2787 2788 } else { 2789 $elNames = array($element->getName()); 2790 } 2791 2792 return $elNames; 2793 } 2794 2795 /** 2796 * Adds a dependency for $elementName which will be disabled if $condition is met. 2797 * If $condition = 'notchecked' (default) then the condition is that the $dependentOn element 2798 * is not checked. If $condition = 'checked' then the condition is that the $dependentOn element 2799 * is checked. If $condition is something else (like "eq" for equals) then it is checked to see if the value 2800 * of the $dependentOn element is $condition (such as equal) to $value. 2801 * 2802 * When working with multiple selects, the dependentOn has to be the real name of the select, meaning that 2803 * it will most likely end up with '[]'. Also, the value should be an array of required values, or a string 2804 * containing the values separated by pipes: array('red', 'blue') or 'red|blue'. 2805 * 2806 * @param string $elementName the name of the element which will be disabled 2807 * @param string $dependentOn the name of the element whose state will be checked for condition 2808 * @param string $condition the condition to check 2809 * @param mixed $value used in conjunction with condition. 2810 */ 2811 function disabledIf($elementName, $dependentOn, $condition = 'notchecked', $value='1') { 2812 // Multiple selects allow for a multiple selection, we transform the array to string here as 2813 // an array cannot be used as a key in an associative array. 2814 if (is_array($value)) { 2815 $value = implode('|', $value); 2816 } 2817 if (!array_key_exists($dependentOn, $this->_dependencies)) { 2818 $this->_dependencies[$dependentOn] = array(); 2819 } 2820 if (!array_key_exists($condition, $this->_dependencies[$dependentOn])) { 2821 $this->_dependencies[$dependentOn][$condition] = array(); 2822 } 2823 if (!array_key_exists($value, $this->_dependencies[$dependentOn][$condition])) { 2824 $this->_dependencies[$dependentOn][$condition][$value] = array(); 2825 } 2826 $this->_dependencies[$dependentOn][$condition][$value][] = $elementName; 2827 } 2828 2829 /** 2830 * Adds a dependency for $elementName which will be hidden if $condition is met. 2831 * If $condition = 'notchecked' (default) then the condition is that the $dependentOn element 2832 * is not checked. If $condition = 'checked' then the condition is that the $dependentOn element 2833 * is checked. If $condition is something else (like "eq" for equals) then it is checked to see if the value 2834 * of the $dependentOn element is $condition (such as equal) to $value. 2835 * 2836 * When working with multiple selects, the dependentOn has to be the real name of the select, meaning that 2837 * it will most likely end up with '[]'. Also, the value should be an array of required values, or a string 2838 * containing the values separated by pipes: array('red', 'blue') or 'red|blue'. 2839 * 2840 * @param string $elementname the name of the element which will be hidden 2841 * @param string $dependenton the name of the element whose state will be checked for condition 2842 * @param string $condition the condition to check 2843 * @param mixed $value used in conjunction with condition. 2844 */ 2845 public function hideIf($elementname, $dependenton, $condition = 'notchecked', $value = '1') { 2846 // Multiple selects allow for a multiple selection, we transform the array to string here as 2847 // an array cannot be used as a key in an associative array. 2848 if (is_array($value)) { 2849 $value = implode('|', $value); 2850 } 2851 if (!array_key_exists($dependenton, $this->_hideifs)) { 2852 $this->_hideifs[$dependenton] = array(); 2853 } 2854 if (!array_key_exists($condition, $this->_hideifs[$dependenton])) { 2855 $this->_hideifs[$dependenton][$condition] = array(); 2856 } 2857 if (!array_key_exists($value, $this->_hideifs[$dependenton][$condition])) { 2858 $this->_hideifs[$dependenton][$condition][$value] = array(); 2859 } 2860 $this->_hideifs[$dependenton][$condition][$value][] = $elementname; 2861 } 2862 2863 /** 2864 * Registers button as no submit button 2865 * 2866 * @param string $buttonname name of the button 2867 */ 2868 function registerNoSubmitButton($buttonname){ 2869 $this->_noSubmitButtons[]=$buttonname; 2870 } 2871 2872 /** 2873 * Checks if button is a no submit button, i.e it doesn't submit form 2874 * 2875 * @param string $buttonname name of the button to check 2876 * @return bool 2877 */ 2878 function isNoSubmitButton($buttonname){ 2879 return (array_search($buttonname, $this->_noSubmitButtons)!==FALSE); 2880 } 2881 2882 /** 2883 * Registers a button as cancel button 2884 * 2885 * @param string $addfieldsname name of the button 2886 */ 2887 function _registerCancelButton($addfieldsname){ 2888 $this->_cancelButtons[]=$addfieldsname; 2889 } 2890 2891 /** 2892 * Displays elements without HTML input tags. 2893 * This method is different to freeze() in that it makes sure no hidden 2894 * elements are included in the form. 2895 * Note: If you want to make sure the submitted value is ignored, please use setDefaults(). 2896 * 2897 * This function also removes all previously defined rules. 2898 * 2899 * @param string|array $elementList array or string of element(s) to be frozen 2900 * @return object|bool if element list is not empty then return error object, else true 2901 */ 2902 function hardFreeze($elementList=null) 2903 { 2904 if (!isset($elementList)) { 2905 $this->_freezeAll = true; 2906 $elementList = array(); 2907 } else { 2908 if (!is_array($elementList)) { 2909 $elementList = preg_split('/[ ]*,[ ]*/', $elementList); 2910 } 2911 $elementList = array_flip($elementList); 2912 } 2913 2914 foreach (array_keys($this->_elements) as $key) { 2915 $name = $this->_elements[$key]->getName(); 2916 if ($this->_freezeAll || isset($elementList[$name])) { 2917 $this->_elements[$key]->freeze(); 2918 $this->_elements[$key]->setPersistantFreeze(false); 2919 unset($elementList[$name]); 2920 2921 // remove all rules 2922 $this->_rules[$name] = array(); 2923 // if field is required, remove the rule 2924 $unset = array_search($name, $this->_required); 2925 if ($unset !== false) { 2926 unset($this->_required[$unset]); 2927 } 2928 } 2929 } 2930 2931 if (!empty($elementList)) { 2932 return self::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Nonexistant element(s): '" . implode("', '", array_keys($elementList)) . "' in HTML_QuickForm::freeze()", 'HTML_QuickForm_Error', true); 2933 } 2934 return true; 2935 } 2936 2937 /** 2938 * Hard freeze all elements in a form except those whose names are in $elementList or hidden elements in a form. 2939 * 2940 * This function also removes all previously defined rules of elements it freezes. 2941 * 2942 * @throws HTML_QuickForm_Error 2943 * @param array $elementList array or string of element(s) not to be frozen 2944 * @return bool returns true 2945 */ 2946 function hardFreezeAllVisibleExcept($elementList) 2947 { 2948 $elementList = array_flip($elementList); 2949 foreach (array_keys($this->_elements) as $key) { 2950 $name = $this->_elements[$key]->getName(); 2951 $type = $this->_elements[$key]->getType(); 2952 2953 if ($type == 'hidden'){ 2954 // leave hidden types as they are 2955 } elseif (!isset($elementList[$name])) { 2956 $this->_elements[$key]->freeze(); 2957 $this->_elements[$key]->setPersistantFreeze(false); 2958 2959 // remove all rules 2960 $this->_rules[$name] = array(); 2961 // if field is required, remove the rule 2962 $unset = array_search($name, $this->_required); 2963 if ($unset !== false) { 2964 unset($this->_required[$unset]); 2965 } 2966 } 2967 } 2968 return true; 2969 } 2970 2971 /** 2972 * Tells whether the form was already submitted 2973 * 2974 * This is useful since the _submitFiles and _submitValues arrays 2975 * may be completely empty after the trackSubmit value is removed. 2976 * 2977 * @return bool 2978 */ 2979 function isSubmitted() 2980 { 2981 return parent::isSubmitted() && (!$this->isFrozen()); 2982 } 2983 2984 /** 2985 * Add the element name to the list of newly-created repeat elements 2986 * (So that elements that interpret 'no data submitted' as a valid state 2987 * can tell when they should get the default value instead). 2988 * 2989 * @param string $name the name of the new element 2990 */ 2991 public function note_new_repeat($name) { 2992 $this->_newrepeats[] = $name; 2993 } 2994 2995 /** 2996 * Check if the element with the given name has just been added by clicking 2997 * on the 'Add repeating elements' button. 2998 * 2999 * @param string $name the name of the element being checked 3000 * @return bool true if the element is newly added 3001 */ 3002 public function is_new_repeat($name) { 3003 return in_array($name, $this->_newrepeats); 3004 } 3005 } 3006 3007 /** 3008 * MoodleQuickForm renderer 3009 * 3010 * A renderer for MoodleQuickForm that only uses XHTML and CSS and no 3011 * table tags, extends PEAR class HTML_QuickForm_Renderer_Tableless 3012 * 3013 * Stylesheet is part of standard theme and should be automatically included. 3014 * 3015 * @package core_form 3016 * @copyright 2007 Jamie Pratt <me@jamiep.org> 3017 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 3018 */ 3019 class MoodleQuickForm_Renderer extends HTML_QuickForm_Renderer_Tableless{ 3020 3021 /** @var array Element template array */ 3022 var $_elementTemplates; 3023 3024 /** 3025 * Template used when opening a hidden fieldset 3026 * (i.e. a fieldset that is opened when there is no header element) 3027 * @var string 3028 */ 3029 var $_openHiddenFieldsetTemplate = "\n\t<fieldset class=\"hidden\"><div>"; 3030 3031 /** @var string Template used when opening a fieldset */ 3032 var $_openFieldsetTemplate = "\n\t<fieldset class=\"{classes}\" {id}>"; 3033 3034 /** @var string Template used when closing a fieldset */ 3035 var $_closeFieldsetTemplate = "\n\t\t</div></fieldset>"; 3036 3037 /** @var string Required Note template string */ 3038 var $_requiredNoteTemplate = 3039 "\n\t\t<div class=\"fdescription required\">{requiredNote}</div>"; 3040 3041 /** 3042 * Collapsible buttons string template. 3043 * 3044 * Note that the <span> will be converted as a link. This is done so that the link is not yet clickable 3045 * until the Javascript has been fully loaded. 3046 * 3047 * @var string 3048 */ 3049 var $_collapseButtonsTemplate = 3050 "\n\t<div class=\"collapsible-actions\"><span class=\"collapseexpand\">{strexpandall}</span></div>"; 3051 3052 /** 3053 * Array whose keys are element names. If the key exists this is a advanced element 3054 * 3055 * @var array 3056 */ 3057 var $_advancedElements = array(); 3058 3059 /** 3060 * Array whose keys are element names and the the boolean values reflect the current state. If the key exists this is a collapsible element. 3061 * 3062 * @var array 3063 */ 3064 var $_collapsibleElements = array(); 3065 3066 /** 3067 * @var string Contains the collapsible buttons to add to the form. 3068 */ 3069 var $_collapseButtons = ''; 3070 3071 /** @var string request class HTML. */ 3072 protected $_reqHTML; 3073 3074 /** @var string advanced class HTML. */ 3075 protected $_advancedHTML; 3076 3077 /** 3078 * Constructor 3079 */ 3080 public function __construct() { 3081 // switch next two lines for ol li containers for form items. 3082 // $this->_elementTemplates=array('default'=>"\n\t\t".'<li class="fitem"><label>{label}{help}<!-- BEGIN required -->{req}<!-- END required --></label><div class="qfelement<!-- BEGIN error --> error<!-- END error --> {typeclass}"><!-- BEGIN error --><span class="error">{error}</span><br /><!-- END error -->{element}</div></li>'); 3083 $this->_elementTemplates = array( 3084 'default' => "\n\t\t".'<div id="{id}" class="fitem {advanced}<!-- BEGIN required --> required<!-- END required --> fitem_{typeclass} {emptylabel} {class}" {aria-live} {groupname}><div class="fitemtitle"><label>{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} </label>{help}</div><div class="felement {typeclass}<!-- BEGIN error --> error<!-- END error -->" data-fieldtype="{type}"><!-- BEGIN error --><span class="error" tabindex="0">{error}</span><br /><!-- END error -->{element}</div></div>', 3085 3086 'actionbuttons' => "\n\t\t".'<div id="{id}" class="fitem fitem_actionbuttons fitem_{typeclass} {class}" {groupname}><div class="felement {typeclass}" data-fieldtype="{type}">{element}</div></div>', 3087 3088 'fieldset' => "\n\t\t".'<div id="{id}" class="fitem {advanced} {class}<!-- BEGIN required --> required<!-- END required --> fitem_{typeclass} {emptylabel}" {groupname}><div class="fitemtitle"><div class="fgrouplabel"><label>{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} </label>{help}</div></div><fieldset class="felement {typeclass}<!-- BEGIN error --> error<!-- END error -->" data-fieldtype="{type}"><!-- BEGIN error --><span class="error" tabindex="0">{error}</span><br /><!-- END error -->{element}</fieldset></div>', 3089 3090 'static' => "\n\t\t".'<div id="{id}" class="fitem {advanced} {emptylabel} {class}" {groupname}><div class="fitemtitle"><div class="fstaticlabel">{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} {help}</div></div><div class="felement fstatic <!-- BEGIN error --> error<!-- END error -->" data-fieldtype="static"><!-- BEGIN error --><span class="error" tabindex="0">{error}</span><br /><!-- END error -->{element}</div></div>', 3091 3092 'warning' => "\n\t\t".'<div id="{id}" class="fitem {advanced} {emptylabel} {class}">{element}</div>', 3093 3094 'nodisplay' => ''); 3095 3096 parent::__construct(); 3097 } 3098 3099 /** 3100 * Old syntax of class constructor. Deprecated in PHP7. 3101 * 3102 * @deprecated since Moodle 3.1 3103 */ 3104 public function MoodleQuickForm_Renderer() { 3105 debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER); 3106 self::__construct(); 3107 } 3108 3109 /** 3110 * Set element's as adavance element 3111 * 3112 * @param array $elements form elements which needs to be grouped as advance elements. 3113 */ 3114 function setAdvancedElements($elements){ 3115 $this->_advancedElements = $elements; 3116 } 3117 3118 /** 3119 * Setting collapsible elements 3120 * 3121 * @param array $elements 3122 */ 3123 function setCollapsibleElements($elements) { 3124 $this->_collapsibleElements = $elements; 3125 } 3126 3127 /** 3128 * What to do when starting the form 3129 * 3130 * @param MoodleQuickForm $form reference of the form 3131 */ 3132 function startForm(&$form){ 3133 global $PAGE, $OUTPUT; 3134 $this->_reqHTML = $form->getReqHTML(); 3135 $this->_elementTemplates = str_replace('{req}', $this->_reqHTML, $this->_elementTemplates); 3136 $this->_advancedHTML = $form->getAdvancedHTML(); 3137 $this->_collapseButtons = ''; 3138 $formid = $form->getAttribute('id'); 3139 parent::startForm($form); 3140 if ($form->isFrozen()){ 3141 $this->_formTemplate = "\n<div id=\"$formid\" class=\"mform frozen\">\n{collapsebtns}\n{content}\n</div>"; 3142 } else { 3143 $this->_formTemplate = "\n<form{attributes}>\n\t<div style=\"display: none;\">{hidden}</div>\n{collapsebtns}\n{content}\n</form>"; 3144 $this->_hiddenHtml .= $form->_pageparams; 3145 } 3146 3147 if ($form->is_form_change_checker_enabled()) { 3148 $PAGE->requires->js_call_amd('core_form/changechecker', 'watchFormById', [$formid]); 3149 if ($form->is_dirty()) { 3150 $PAGE->requires->js_call_amd('core_form/changechecker', 'markFormAsDirtyById', [$formid]); 3151 } 3152 } 3153 if (!empty($this->_collapsibleElements)) { 3154 if (count($this->_collapsibleElements) > 1) { 3155 $this->_collapseButtons = $OUTPUT->render_from_template('core_form/collapsesections', (object)[]); 3156 } 3157 $PAGE->requires->yui_module('moodle-form-shortforms', 'M.form.shortforms', array(array('formid' => $formid))); 3158 } 3159 if (!empty($this->_advancedElements)){ 3160 $PAGE->requires->js_call_amd('core_form/showadvanced', 'init', [$formid]); 3161 } 3162 } 3163 3164 /** 3165 * Create advance group of elements 3166 * 3167 * @param MoodleQuickForm_group $group Passed by reference 3168 * @param bool $required if input is required field 3169 * @param string $error error message to display 3170 */ 3171 function startGroup(&$group, $required, $error){ 3172 global $OUTPUT; 3173 3174 // Make sure the element has an id. 3175 $group->_generateId(); 3176 3177 // Prepend 'fgroup_' to the ID we generated. 3178 $groupid = 'fgroup_' . $group->getAttribute('id'); 3179 3180 // Update the ID. 3181 $group->updateAttributes(array('id' => $groupid)); 3182 $advanced = isset($this->_advancedElements[$group->getName()]); 3183 3184 $html = $OUTPUT->mform_element($group, $required, $advanced, $error, false); 3185 $fromtemplate = !empty($html); 3186 if (!$fromtemplate) { 3187 if (method_exists($group, 'getElementTemplateType')) { 3188 $html = $this->_elementTemplates[$group->getElementTemplateType()]; 3189 } else { 3190 $html = $this->_elementTemplates['default']; 3191 } 3192 3193 if (isset($this->_advancedElements[$group->getName()])) { 3194 $html = str_replace(' {advanced}', ' advanced', $html); 3195 $html = str_replace('{advancedimg}', $this->_advancedHTML, $html); 3196 } else { 3197 $html = str_replace(' {advanced}', '', $html); 3198 $html = str_replace('{advancedimg}', '', $html); 3199 } 3200 if (method_exists($group, 'getHelpButton')) { 3201 $html = str_replace('{help}', $group->getHelpButton(), $html); 3202 } else { 3203 $html = str_replace('{help}', '', $html); 3204 } 3205 $html = str_replace('{id}', $group->getAttribute('id'), $html); 3206 $html = str_replace('{name}', $group->getName(), $html); 3207 $html = str_replace('{groupname}', 'data-groupname="'.$group->getName().'"', $html); 3208 $html = str_replace('{typeclass}', 'fgroup', $html); 3209 $html = str_replace('{type}', 'group', $html); 3210 $html = str_replace('{class}', $group->getAttribute('class') ?? '', $html); 3211 $emptylabel = ''; 3212 if ($group->getLabel() == '') { 3213 $emptylabel = 'femptylabel'; 3214 } 3215 $html = str_replace('{emptylabel}', $emptylabel, $html); 3216 } 3217 $this->_templates[$group->getName()] = $html; 3218 // Fix for bug in tableless quickforms that didn't allow you to stop a 3219 // fieldset before a group of elements. 3220 // if the element name indicates the end of a fieldset, close the fieldset 3221 if (in_array($group->getName(), $this->_stopFieldsetElements) && $this->_fieldsetsOpen > 0) { 3222 $this->_html .= $this->_closeFieldsetTemplate; 3223 $this->_fieldsetsOpen--; 3224 } 3225 if (!$fromtemplate) { 3226 parent::startGroup($group, $required, $error); 3227 } else { 3228 $this->_html .= $html; 3229 } 3230 } 3231 3232 /** 3233 * Renders element 3234 * 3235 * @param HTML_QuickForm_element $element element 3236 * @param bool $required if input is required field 3237 * @param string $error error message to display 3238 */ 3239 function renderElement(&$element, $required, $error){ 3240 global $OUTPUT; 3241 3242 // Make sure the element has an id. 3243 $element->_generateId(); 3244 $advanced = isset($this->_advancedElements[$element->getName()]); 3245 3246 $html = $OUTPUT->mform_element($element, $required, $advanced, $error, false); 3247 $fromtemplate = !empty($html); 3248 if (!$fromtemplate) { 3249 // Adding stuff to place holders in template 3250 // check if this is a group element first. 3251 if (($this->_inGroup) and !empty($this->_groupElementTemplate)) { 3252 // So it gets substitutions for *each* element. 3253 $html = $this->_groupElementTemplate; 3254 } else if (method_exists($element, 'getElementTemplateType')) { 3255 $html = $this->_elementTemplates[$element->getElementTemplateType()]; 3256 } else { 3257 $html = $this->_elementTemplates['default']; 3258 } 3259 if (isset($this->_advancedElements[$element->getName()])) { 3260 $html = str_replace(' {advanced}', ' advanced', $html); 3261 $html = str_replace(' {aria-live}', ' aria-live="polite"', $html); 3262 } else { 3263 $html = str_replace(' {advanced}', '', $html); 3264 $html = str_replace(' {aria-live}', '', $html); 3265 } 3266 if (isset($this->_advancedElements[$element->getName()]) || $element->getName() == 'mform_showadvanced') { 3267 $html = str_replace('{advancedimg}', $this->_advancedHTML, $html); 3268 } else { 3269 $html = str_replace('{advancedimg}', '', $html); 3270 } 3271 $html = str_replace('{id}', 'fitem_' . $element->getAttribute('id'), $html); 3272 $html = str_replace('{typeclass}', 'f' . $element->getType(), $html); 3273 $html = str_replace('{type}', $element->getType(), $html); 3274 $html = str_replace('{name}', $element->getName(), $html); 3275 $html = str_replace('{groupname}', '', $html); 3276 $html = str_replace('{class}', $element->getAttribute('class') ?? '', $html); 3277 $emptylabel = ''; 3278 if ($element->getLabel() == '') { 3279 $emptylabel = 'femptylabel'; 3280 } 3281 $html = str_replace('{emptylabel}', $emptylabel, $html); 3282 if (method_exists($element, 'getHelpButton')) { 3283 $html = str_replace('{help}', $element->getHelpButton(), $html); 3284 } else { 3285 $html = str_replace('{help}', '', $html); 3286 } 3287 } else { 3288 if ($this->_inGroup) { 3289 $this->_groupElementTemplate = $html; 3290 } 3291 } 3292 if (($this->_inGroup) and !empty($this->_groupElementTemplate)) { 3293 $this->_groupElementTemplate = $html; 3294 } else if (!isset($this->_templates[$element->getName()])) { 3295 $this->_templates[$element->getName()] = $html; 3296 } 3297 3298 if (!$fromtemplate) { 3299 parent::renderElement($element, $required, $error); 3300 } else { 3301 if (in_array($element->getName(), $this->_stopFieldsetElements) && $this->_fieldsetsOpen > 0) { 3302 $this->_html .= $this->_closeFieldsetTemplate; 3303 $this->_fieldsetsOpen--; 3304 } 3305 $this->_html .= $html; 3306 } 3307 } 3308 3309 /** 3310 * Called when visiting a form, after processing all form elements 3311 * Adds required note, form attributes, validation javascript and form content. 3312 * 3313 * @global moodle_page $PAGE 3314 * @param MoodleQuickForm $form Passed by reference 3315 */ 3316 function finishForm(&$form){ 3317 global $PAGE; 3318 if ($form->isFrozen()){ 3319 $this->_hiddenHtml = ''; 3320 } 3321 parent::finishForm($form); 3322 $this->_html = str_replace('{collapsebtns}', $this->_collapseButtons, $this->_html); 3323 if (!$form->isFrozen()) { 3324 $args = $form->getLockOptionObject(); 3325 if (count($args[1]) > 0) { 3326 $PAGE->requires->js_init_call('M.form.initFormDependencies', $args, true, moodleform::get_js_module()); 3327 } 3328 } 3329 } 3330 /** 3331 * Called when visiting a header element 3332 * 3333 * @param HTML_QuickForm_header $header An HTML_QuickForm_header element being visited 3334 * @global moodle_page $PAGE 3335 */ 3336 function renderHeader(&$header) { 3337 global $PAGE, $OUTPUT; 3338 3339 $header->_generateId(); 3340 $name = $header->getName(); 3341 3342 $collapsed = $collapseable = ''; 3343 if (isset($this->_collapsibleElements[$header->getName()])) { 3344 $collapseable = true; 3345 $collapsed = $this->_collapsibleElements[$header->getName()]; 3346 } 3347 3348 $id = empty($name) ? '' : ' id="' . $header->getAttribute('id') . '"'; 3349 if (!empty($name) && isset($this->_templates[$name])) { 3350 $headerhtml = str_replace('{header}', $header->toHtml(), $this->_templates[$name]); 3351 } else { 3352 $headerhtml = $OUTPUT->render_from_template('core_form/element-header', 3353 (object)[ 3354 'header' => $header->toHtml(), 3355 'id' => $header->getAttribute('id'), 3356 'collapseable' => $collapseable, 3357 'collapsed' => $collapsed, 3358 'helpbutton' => $header->getHelpButton(), 3359 ]); 3360 } 3361 3362 if ($this->_fieldsetsOpen > 0) { 3363 $this->_html .= $this->_closeFieldsetTemplate; 3364 $this->_fieldsetsOpen--; 3365 } 3366 3367 // Define collapsible classes for fieldsets. 3368 $arialive = ''; 3369 $fieldsetclasses = array('clearfix'); 3370 if (isset($this->_collapsibleElements[$header->getName()])) { 3371 $fieldsetclasses[] = 'collapsible'; 3372 if ($this->_collapsibleElements[$header->getName()]) { 3373 $fieldsetclasses[] = 'collapsed'; 3374 } 3375 } 3376 3377 if (isset($this->_advancedElements[$name])){ 3378 $fieldsetclasses[] = 'containsadvancedelements'; 3379 } 3380 3381 $openFieldsetTemplate = str_replace('{id}', $id, $this->_openFieldsetTemplate); 3382 $openFieldsetTemplate = str_replace('{classes}', join(' ', $fieldsetclasses), $openFieldsetTemplate); 3383 3384 $this->_html .= $openFieldsetTemplate . $headerhtml; 3385 $this->_fieldsetsOpen++; 3386 } 3387 3388 /** 3389 * Return Array of element names that indicate the end of a fieldset 3390 * 3391 * @return array 3392 */ 3393 function getStopFieldsetElements(){ 3394 return $this->_stopFieldsetElements; 3395 } 3396 } 3397 3398 /** 3399 * Required elements validation 3400 * 3401 * This class overrides QuickForm validation since it allowed space or empty tag as a value 3402 * 3403 * @package core_form 3404 * @category form 3405 * @copyright 2006 Jamie Pratt <me@jamiep.org> 3406 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 3407 */ 3408 class MoodleQuickForm_Rule_Required extends HTML_QuickForm_Rule { 3409 /** 3410 * Checks if an element is not empty. 3411 * This is a server-side validation, it works for both text fields and editor fields 3412 * 3413 * @param string $value Value to check 3414 * @param int|string|array $options Not used yet 3415 * @return bool true if value is not empty 3416 */ 3417 function validate($value, $options = null) { 3418 global $CFG; 3419 if (is_array($value) && array_key_exists('text', $value)) { 3420 $value = $value['text']; 3421 } 3422 if (is_array($value)) { 3423 // nasty guess - there has to be something in the array, hopefully nobody invents arrays in arrays 3424 $value = implode('', $value); 3425 } 3426 $stripvalues = array( 3427 '#</?(?!img|canvas|hr).*?>#im', // all tags except img, canvas and hr 3428 '#(\xc2\xa0|\s| )#', // Any whitespaces actually. 3429 ); 3430 if (!empty($CFG->strictformsrequired)) { 3431 $value = preg_replace($stripvalues, '', (string)$value); 3432 } 3433 if ((string)$value == '') { 3434 return false; 3435 } 3436 return true; 3437 } 3438 3439 /** 3440 * This function returns Javascript code used to build client-side validation. 3441 * It checks if an element is not empty. 3442 * 3443 * @param int $format format of data which needs to be validated. 3444 * @return array 3445 */ 3446 function getValidationScript($format = null) { 3447 global $CFG; 3448 if (!empty($CFG->strictformsrequired)) { 3449 if (!empty($format) && $format == FORMAT_HTML) { 3450 return array('', "{jsVar}.replace(/(<(?!img|hr|canvas)[^>]*>)| |\s+/ig, '') == ''"); 3451 } else { 3452 return array('', "{jsVar}.replace(/^\s+$/g, '') == ''"); 3453 } 3454 } else { 3455 return array('', "{jsVar} == ''"); 3456 } 3457 } 3458 } 3459 3460 /** 3461 * @global object $GLOBALS['_HTML_QuickForm_default_renderer'] 3462 * @name $_HTML_QuickForm_default_renderer 3463 */ 3464 $GLOBALS['_HTML_QuickForm_default_renderer'] = new MoodleQuickForm_Renderer(); 3465 3466 /** Please keep this list in alphabetical order. */ 3467 MoodleQuickForm::registerElementType('advcheckbox', "$CFG->libdir/form/advcheckbox.php", 'MoodleQuickForm_advcheckbox'); 3468 MoodleQuickForm::registerElementType('autocomplete', "$CFG->libdir/form/autocomplete.php", 'MoodleQuickForm_autocomplete'); 3469 MoodleQuickForm::registerElementType('button', "$CFG->libdir/form/button.php", 'MoodleQuickForm_button'); 3470 MoodleQuickForm::registerElementType('cancel', "$CFG->libdir/form/cancel.php", 'MoodleQuickForm_cancel'); 3471 MoodleQuickForm::registerElementType('course', "$CFG->libdir/form/course.php", 'MoodleQuickForm_course'); 3472 MoodleQuickForm::registerElementType('cohort', "$CFG->libdir/form/cohort.php", 'MoodleQuickForm_cohort'); 3473 MoodleQuickForm::registerElementType('searchableselector', "$CFG->libdir/form/searchableselector.php", 'MoodleQuickForm_searchableselector'); 3474 MoodleQuickForm::registerElementType('checkbox', "$CFG->libdir/form/checkbox.php", 'MoodleQuickForm_checkbox'); 3475 MoodleQuickForm::registerElementType('date_selector', "$CFG->libdir/form/dateselector.php", 'MoodleQuickForm_date_selector'); 3476 MoodleQuickForm::registerElementType('date_time_selector', "$CFG->libdir/form/datetimeselector.php", 'MoodleQuickForm_date_time_selector'); 3477 MoodleQuickForm::registerElementType('duration', "$CFG->libdir/form/duration.php", 'MoodleQuickForm_duration'); 3478 MoodleQuickForm::registerElementType('editor', "$CFG->libdir/form/editor.php", 'MoodleQuickForm_editor'); 3479 MoodleQuickForm::registerElementType('filemanager', "$CFG->libdir/form/filemanager.php", 'MoodleQuickForm_filemanager'); 3480 MoodleQuickForm::registerElementType('filepicker', "$CFG->libdir/form/filepicker.php", 'MoodleQuickForm_filepicker'); 3481 MoodleQuickForm::registerElementType('filetypes', "$CFG->libdir/form/filetypes.php", 'MoodleQuickForm_filetypes'); 3482 MoodleQuickForm::registerElementType('float', "$CFG->libdir/form/float.php", 'MoodleQuickForm_float'); 3483 MoodleQuickForm::registerElementType('grading', "$CFG->libdir/form/grading.php", 'MoodleQuickForm_grading'); 3484 MoodleQuickForm::registerElementType('group', "$CFG->libdir/form/group.php", 'MoodleQuickForm_group'); 3485 MoodleQuickForm::registerElementType('header', "$CFG->libdir/form/header.php", 'MoodleQuickForm_header'); 3486 MoodleQuickForm::registerElementType('hidden', "$CFG->libdir/form/hidden.php", 'MoodleQuickForm_hidden'); 3487 MoodleQuickForm::registerElementType('listing', "$CFG->libdir/form/listing.php", 'MoodleQuickForm_listing'); 3488 MoodleQuickForm::registerElementType('defaultcustom', "$CFG->libdir/form/defaultcustom.php", 'MoodleQuickForm_defaultcustom'); 3489 MoodleQuickForm::registerElementType('modgrade', "$CFG->libdir/form/modgrade.php", 'MoodleQuickForm_modgrade'); 3490 MoodleQuickForm::registerElementType('modvisible', "$CFG->libdir/form/modvisible.php", 'MoodleQuickForm_modvisible'); 3491 MoodleQuickForm::registerElementType('password', "$CFG->libdir/form/password.php", 'MoodleQuickForm_password'); 3492 MoodleQuickForm::registerElementType('passwordunmask', "$CFG->libdir/form/passwordunmask.php", 'MoodleQuickForm_passwordunmask'); 3493 MoodleQuickForm::registerElementType('questioncategory', "$CFG->libdir/form/questioncategory.php", 'MoodleQuickForm_questioncategory'); 3494 MoodleQuickForm::registerElementType('radio', "$CFG->libdir/form/radio.php", 'MoodleQuickForm_radio'); 3495 MoodleQuickForm::registerElementType('recaptcha', "$CFG->libdir/form/recaptcha.php", 'MoodleQuickForm_recaptcha'); 3496 MoodleQuickForm::registerElementType('select', "$CFG->libdir/form/select.php", 'MoodleQuickForm_select'); 3497 MoodleQuickForm::registerElementType('selectgroups', "$CFG->libdir/form/selectgroups.php", 'MoodleQuickForm_selectgroups'); 3498 MoodleQuickForm::registerElementType('selectwithlink', "$CFG->libdir/form/selectwithlink.php", 'MoodleQuickForm_selectwithlink'); 3499 MoodleQuickForm::registerElementType('selectyesno', "$CFG->libdir/form/selectyesno.php", 'MoodleQuickForm_selectyesno'); 3500 MoodleQuickForm::registerElementType('static', "$CFG->libdir/form/static.php", 'MoodleQuickForm_static'); 3501 MoodleQuickForm::registerElementType('submit', "$CFG->libdir/form/submit.php", 'MoodleQuickForm_submit'); 3502 MoodleQuickForm::registerElementType('tags', "$CFG->libdir/form/tags.php", 'MoodleQuickForm_tags'); 3503 MoodleQuickForm::registerElementType('text', "$CFG->libdir/form/text.php", 'MoodleQuickForm_text'); 3504 MoodleQuickForm::registerElementType('textarea', "$CFG->libdir/form/textarea.php", 'MoodleQuickForm_textarea'); 3505 MoodleQuickForm::registerElementType('url', "$CFG->libdir/form/url.php", 'MoodleQuickForm_url'); 3506 MoodleQuickForm::registerElementType('warning', "$CFG->libdir/form/warning.php", 'MoodleQuickForm_warning'); 3507 3508 MoodleQuickForm::registerRule('required', null, 'MoodleQuickForm_Rule_Required', "$CFG->libdir/formslib.php");
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
