Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
- Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
- PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
/search/classes/ -> manager.php (source)
Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]
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 * Search subsystem manager. 19 * 20 * @package core_search 21 * @copyright Prateek Sachan {@link http://prateeksachan.com} 22 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 23 */ 24 25 namespace core_search; 26 27 defined('MOODLE_INTERNAL') || die; 28 29 require_once($CFG->dirroot . '/lib/accesslib.php'); 30 31 /** 32 * Search subsystem manager. 33 * 34 * @package core_search 35 * @copyright Prateek Sachan {@link http://prateeksachan.com} 36 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 37 */ 38 class manager { 39 40 /** 41 * @var int Text contents. 42 */ 43 const TYPE_TEXT = 1; 44 45 /** 46 * @var int File contents. 47 */ 48 const TYPE_FILE = 2; 49 50 /** 51 * @var int User can not access the document. 52 */ 53 const ACCESS_DENIED = 0; 54 55 /** 56 * @var int User can access the document. 57 */ 58 const ACCESS_GRANTED = 1; 59 60 /** 61 * @var int The document was deleted. 62 */ 63 const ACCESS_DELETED = 2; 64 65 /** 66 * @var int Maximum number of results that will be retrieved from the search engine. 67 */ 68 const MAX_RESULTS = 100; 69 70 /** 71 * @var int Number of results per page. 72 */ 73 const DISPLAY_RESULTS_PER_PAGE = 10; 74 75 /** 76 * @var int The id to be placed in owneruserid when there is no owner. 77 */ 78 const NO_OWNER_ID = 0; 79 80 /** 81 * @var float If initial query takes longer than N seconds, this will be shown in cron log. 82 */ 83 const DISPLAY_LONG_QUERY_TIME = 5.0; 84 85 /** 86 * @var float Adds indexing progress within one search area to cron log every N seconds. 87 */ 88 const DISPLAY_INDEXING_PROGRESS_EVERY = 30.0; 89 90 /** 91 * @var int Context indexing: normal priority. 92 */ 93 const INDEX_PRIORITY_NORMAL = 100; 94 95 /** 96 * @var int Context indexing: low priority for reindexing. 97 */ 98 const INDEX_PRIORITY_REINDEXING = 50; 99 100 /** 101 * @var string Core search area category for all results. 102 */ 103 const SEARCH_AREA_CATEGORY_ALL = 'core-all'; 104 105 /** 106 * @var string Core search area category for course content. 107 */ 108 const SEARCH_AREA_CATEGORY_COURSE_CONTENT = 'core-course-content'; 109 110 /** 111 * @var string Core search area category for courses. 112 */ 113 const SEARCH_AREA_CATEGORY_COURSES = 'core-courses'; 114 115 /** 116 * @var string Core search area category for users. 117 */ 118 const SEARCH_AREA_CATEGORY_USERS = 'core-users'; 119 120 /** 121 * @var string Core search area category for results that do not fit into any of existing categories. 122 */ 123 const SEARCH_AREA_CATEGORY_OTHER = 'core-other'; 124 125 /** 126 * @var \core_search\base[] Enabled search areas. 127 */ 128 protected static $enabledsearchareas = null; 129 130 /** 131 * @var \core_search\base[] All system search areas. 132 */ 133 protected static $allsearchareas = null; 134 135 /** 136 * @var \core_search\area_category[] A list of search area categories. 137 */ 138 protected static $searchareacategories = null; 139 140 /** 141 * @var \core_search\manager 142 */ 143 protected static $instance = null; 144 145 /** 146 * @var array IDs (as keys) of course deletions in progress in this requuest, if any. 147 */ 148 protected static $coursedeleting = []; 149 150 /** 151 * @var \core_search\engine 152 */ 153 protected $engine = null; 154 155 /** 156 * Note: This should be removed once possible (see MDL-60644). 157 * 158 * @var float Fake current time for use in PHPunit tests 159 */ 160 protected static $phpunitfaketime = 0; 161 162 /** 163 * @var int Result count when used with mock results for Behat tests. 164 */ 165 protected $behatresultcount = 0; 166 167 /** 168 * Constructor, use \core_search\manager::instance instead to get a class instance. 169 * 170 * @param \core_search\base The search engine to use 171 */ 172 public function __construct($engine) { 173 $this->engine = $engine; 174 } 175 176 /** 177 * @var int Record time of each successful schema check, but not more than once per 10 minutes. 178 */ 179 const SCHEMA_CHECK_TRACKING_DELAY = 10 * 60; 180 181 /** 182 * @var int Require a new schema check at least every 4 hours. 183 */ 184 const SCHEMA_CHECK_REQUIRED_EVERY = 4 * 3600; 185 186 /** 187 * Returns an initialised \core_search instance. 188 * 189 * While constructing the instance, checks on the search schema may be carried out. The $fast 190 * parameter provides a way to skip those checks on pages which are used frequently. It has 191 * no effect if an instance has already been constructed in this request. 192 * 193 * The $query parameter indicates that the page is used for queries rather than indexing. If 194 * configured, this will cause the query-only search engine to be used instead of the 'normal' 195 * one. 196 * 197 * @see \core_search\engine::is_installed 198 * @see \core_search\engine::is_server_ready 199 * @param bool $fast Set to true when calling on a page that requires high performance 200 * @param bool $query Set true on a page that is used for querying 201 * @throws \core_search\engine_exception 202 * @return \core_search\manager 203 */ 204 public static function instance(bool $fast = false, bool $query = false) { 205 global $CFG; 206 207 // One per request, this should be purged during testing. 208 if (static::$instance !== null) { 209 return static::$instance; 210 } 211 212 if (empty($CFG->searchengine)) { 213 throw new \core_search\engine_exception('enginenotselected', 'search'); 214 } 215 216 if (!$engine = static::search_engine_instance($query)) { 217 throw new \core_search\engine_exception('enginenotfound', 'search', '', $CFG->searchengine); 218 } 219 220 // Get time now and at last schema check. 221 $now = (int)self::get_current_time(); 222 $lastschemacheck = get_config($engine->get_plugin_name(), 'lastschemacheck'); 223 224 // On pages where performance matters, tell the engine to skip schema checks. 225 $skipcheck = false; 226 if ($fast && $now < $lastschemacheck + self::SCHEMA_CHECK_REQUIRED_EVERY) { 227 $skipcheck = true; 228 $engine->skip_schema_check(); 229 } 230 231 if (!$engine->is_installed()) { 232 throw new \core_search\engine_exception('enginenotinstalled', 'search', '', $CFG->searchengine); 233 } 234 235 $serverstatus = $engine->is_server_ready(); 236 if ($serverstatus !== true) { 237 // Skip this error in Behat when faking seach results. 238 if (!defined('BEHAT_SITE_RUNNING') || !get_config('core_search', 'behat_fakeresult')) { 239 // Clear the record of successful schema checks since it might have failed. 240 unset_config('lastschemacheck', $engine->get_plugin_name()); 241 // Error message with no details as this is an exception that any user may find if the server crashes. 242 throw new \core_search\engine_exception('engineserverstatus', 'search'); 243 } 244 } 245 246 // If we did a successful schema check, record this, but not more than once per 10 minutes 247 // (to avoid updating the config db table/cache too often in case it gets called frequently). 248 if (!$skipcheck && $now >= $lastschemacheck + self::SCHEMA_CHECK_TRACKING_DELAY) { 249 set_config('lastschemacheck', $now, $engine->get_plugin_name()); 250 } 251 252 static::$instance = new \core_search\manager($engine); 253 return static::$instance; 254 } 255 256 /** 257 * Returns whether global search is enabled or not. 258 * 259 * @return bool 260 */ 261 public static function is_global_search_enabled() { 262 global $CFG; 263 return !empty($CFG->enableglobalsearch); 264 } 265 266 /** 267 * Returns the search URL for course search 268 * 269 * @return moodle_url 270 */ 271 public static function get_course_search_url() { 272 if (self::is_global_search_enabled()) { 273 $searchurl = '/search/index.php'; 274 } else { 275 $searchurl = '/course/search.php'; 276 } 277 278 return new \moodle_url($searchurl); 279 } 280 281 /** 282 * Returns whether indexing is enabled or not (you can enable indexing even when search is not 283 * enabled at the moment, so as to have it ready for students). 284 * 285 * @return bool True if indexing is enabled. 286 */ 287 public static function is_indexing_enabled() { 288 global $CFG; 289 return !empty($CFG->enableglobalsearch) || !empty($CFG->searchindexwhendisabled); 290 } 291 292 /** 293 * Returns an instance of the search engine. 294 * 295 * @param bool $query If true, gets the query-only search engine (where configured) 296 * @return \core_search\engine 297 */ 298 public static function search_engine_instance(bool $query = false) { 299 global $CFG; 300 301 if ($query && $CFG->searchenginequeryonly) { 302 return self::search_engine_instance_from_setting($CFG->searchenginequeryonly); 303 } else { 304 return self::search_engine_instance_from_setting($CFG->searchengine); 305 } 306 } 307 308 /** 309 * Loads a search engine based on the name given in settings, which can optionally 310 * include '-alternate' to indicate that an alternate version should be used. 311 * 312 * @param string $setting 313 * @return engine|null 314 */ 315 protected static function search_engine_instance_from_setting(string $setting): ?engine { 316 if (preg_match('~^(.*)-alternate$~', $setting, $matches)) { 317 $enginename = $matches[1]; 318 $alternate = true; 319 } else { 320 $enginename = $setting; 321 $alternate = false; 322 } 323 324 $classname = '\\search_' . $enginename . '\\engine'; 325 if (!class_exists($classname)) { 326 return null; 327 } 328 329 if ($alternate) { 330 return new $classname(true); 331 } else { 332 // Use the constructor with no parameters for compatibility. 333 return new $classname(); 334 } 335 } 336 337 /** 338 * Returns the search engine. 339 * 340 * @return \core_search\engine 341 */ 342 public function get_engine() { 343 return $this->engine; 344 } 345 346 /** 347 * Returns a search area class name. 348 * 349 * @param string $areaid 350 * @return string 351 */ 352 protected static function get_area_classname($areaid) { 353 list($componentname, $areaname) = static::extract_areaid_parts($areaid); 354 return '\\' . $componentname . '\\search\\' . $areaname; 355 } 356 357 /** 358 * Returns a new area search indexer instance. 359 * 360 * @param string $areaid 361 * @return \core_search\base|bool False if the area is not available. 362 */ 363 public static function get_search_area($areaid) { 364 365 // We have them all here. 366 if (!empty(static::$allsearchareas[$areaid])) { 367 return static::$allsearchareas[$areaid]; 368 } 369 370 $classname = static::get_area_classname($areaid); 371 372 if (class_exists($classname) && static::is_search_area($classname)) { 373 return new $classname(); 374 } 375 376 return false; 377 } 378 379 /** 380 * Return the list of available search areas. 381 * 382 * @param bool $enabled Return only the enabled ones. 383 * @return \core_search\base[] 384 */ 385 public static function get_search_areas_list($enabled = false) { 386 387 // Two different arrays, we don't expect these arrays to be big. 388 if (static::$allsearchareas !== null) { 389 if (!$enabled) { 390 return static::$allsearchareas; 391 } else { 392 return static::$enabledsearchareas; 393 } 394 } 395 396 static::$allsearchareas = array(); 397 static::$enabledsearchareas = array(); 398 $searchclasses = \core_component::get_component_classes_in_namespace(null, 'search'); 399 400 foreach ($searchclasses as $classname => $classpath) { 401 $areaname = substr(strrchr($classname, '\\'), 1); 402 $componentname = strstr($classname, '\\', 1); 403 if (!static::is_search_area($classname)) { 404 continue; 405 } 406 407 $areaid = static::generate_areaid($componentname, $areaname); 408 $searchclass = new $classname(); 409 static::$allsearchareas[$areaid] = $searchclass; 410 if ($searchclass->is_enabled()) { 411 static::$enabledsearchareas[$areaid] = $searchclass; 412 } 413 } 414 415 if ($enabled) { 416 return static::$enabledsearchareas; 417 } 418 return static::$allsearchareas; 419 } 420 421 /** 422 * Return search area category instance by category name. 423 * 424 * @param string $name Category name. If name is not valid will return default category. 425 * 426 * @return \core_search\area_category 427 */ 428 public static function get_search_area_category_by_name($name) { 429 if (key_exists($name, self::get_search_area_categories())) { 430 return self::get_search_area_categories()[$name]; 431 } else { 432 return self::get_search_area_categories()[self::get_default_area_category_name()]; 433 } 434 } 435 436 /** 437 * Return a list of existing search area categories. 438 * 439 * @return \core_search\area_category[] 440 */ 441 public static function get_search_area_categories() { 442 if (!isset(static::$searchareacategories)) { 443 $categories = self::get_core_search_area_categories(); 444 445 // Go through all existing search areas and get categories they are assigned to. 446 $areacategories = []; 447 foreach (self::get_search_areas_list() as $searcharea) { 448 foreach ($searcharea->get_category_names() as $categoryname) { 449 if (!key_exists($categoryname, $areacategories)) { 450 $areacategories[$categoryname] = []; 451 } 452 453 $areacategories[$categoryname][] = $searcharea; 454 } 455 } 456 457 // Populate core categories by areas. 458 foreach ($areacategories as $name => $searchareas) { 459 if (key_exists($name, $categories)) { 460 $categories[$name]->set_areas($searchareas); 461 } else { 462 throw new \coding_exception('Unknown core search area category ' . $name); 463 } 464 } 465 466 // Get additional categories. 467 $additionalcategories = self::get_additional_search_area_categories(); 468 foreach ($additionalcategories as $additionalcategory) { 469 if (!key_exists($additionalcategory->get_name(), $categories)) { 470 $categories[$additionalcategory->get_name()] = $additionalcategory; 471 } 472 } 473 474 // Remove categories without areas. 475 foreach ($categories as $key => $category) { 476 if (empty($category->get_areas())) { 477 unset($categories[$key]); 478 } 479 } 480 481 // Sort categories by order. 482 uasort($categories, function($category1, $category2) { 483 return $category1->get_order() <=> $category2->get_order(); 484 }); 485 486 static::$searchareacategories = $categories; 487 } 488 489 return static::$searchareacategories; 490 } 491 492 /** 493 * Get list of core search area categories. 494 * 495 * @return \core_search\area_category[] 496 */ 497 protected static function get_core_search_area_categories() { 498 $categories = []; 499 500 $categories[self::SEARCH_AREA_CATEGORY_ALL] = new area_category( 501 self::SEARCH_AREA_CATEGORY_ALL, 502 get_string('core-all', 'search'), 503 0, 504 self::get_search_areas_list(true) 505 ); 506 507 $categories[self::SEARCH_AREA_CATEGORY_COURSE_CONTENT] = new area_category( 508 self::SEARCH_AREA_CATEGORY_COURSE_CONTENT, 509 get_string('core-course-content', 'search'), 510 1 511 ); 512 513 $categories[self::SEARCH_AREA_CATEGORY_COURSES] = new area_category( 514 self::SEARCH_AREA_CATEGORY_COURSES, 515 get_string('core-courses', 'search'), 516 2 517 ); 518 519 $categories[self::SEARCH_AREA_CATEGORY_USERS] = new area_category( 520 self::SEARCH_AREA_CATEGORY_USERS, 521 get_string('core-users', 'search'), 522 3 523 ); 524 525 $categories[self::SEARCH_AREA_CATEGORY_OTHER] = new area_category( 526 self::SEARCH_AREA_CATEGORY_OTHER, 527 get_string('core-other', 'search'), 528 4 529 ); 530 531 return $categories; 532 } 533 534 /** 535 * Gets a list of additional search area categories. 536 * 537 * @return \core_search\area_category[] 538 */ 539 protected static function get_additional_search_area_categories() { 540 $additionalcategories = []; 541 542 // Allow plugins to add custom search area categories. 543 if ($pluginsfunction = get_plugins_with_function('search_area_categories')) { 544 foreach ($pluginsfunction as $plugintype => $plugins) { 545 foreach ($plugins as $pluginfunction) { 546 $plugincategories = $pluginfunction(); 547 // We're expecting a list of valid area categories. 548 if (is_array($plugincategories)) { 549 foreach ($plugincategories as $plugincategory) { 550 if (self::is_valid_area_category($plugincategory)) { 551 $additionalcategories[] = $plugincategory; 552 } else { 553 throw new \coding_exception('Invalid search area category!'); 554 } 555 } 556 } else { 557 throw new \coding_exception($pluginfunction . ' should return a list of search area categories!'); 558 } 559 } 560 } 561 } 562 563 return $additionalcategories; 564 } 565 566 /** 567 * Check if provided instance of area category is valid. 568 * 569 * @param mixed $areacategory Area category instance. Potentially could be anything. 570 * 571 * @return bool 572 */ 573 protected static function is_valid_area_category($areacategory) { 574 return $areacategory instanceof area_category; 575 } 576 577 /** 578 * Clears all static caches. 579 * 580 * @return void 581 */ 582 public static function clear_static() { 583 584 static::$enabledsearchareas = null; 585 static::$allsearchareas = null; 586 static::$instance = null; 587 static::$searchareacategories = null; 588 589 base_block::clear_static(); 590 engine::clear_users_cache(); 591 } 592 593 /** 594 * Generates an area id from the componentname and the area name. 595 * 596 * There should not be any naming conflict as the area name is the 597 * class name in component/classes/search/. 598 * 599 * @param string $componentname 600 * @param string $areaname 601 * @return void 602 */ 603 public static function generate_areaid($componentname, $areaname) { 604 return $componentname . '-' . $areaname; 605 } 606 607 /** 608 * Returns all areaid string components (component name and area name). 609 * 610 * @param string $areaid 611 * @return array Component name (Frankenstyle) and area name (search area class name) 612 */ 613 public static function extract_areaid_parts($areaid) { 614 return explode('-', $areaid); 615 } 616 617 /** 618 * Parse a search area id and get plugin name and config name prefix from it. 619 * 620 * @param string $areaid Search area id. 621 * @return array Where the first element is a plugin name and the second is config names prefix. 622 */ 623 public static function parse_areaid($areaid) { 624 $parts = self::extract_areaid_parts($areaid); 625 626 if (empty($parts[1])) { 627 throw new \coding_exception('Trying to parse invalid search area id ' . $areaid); 628 } 629 630 $component = $parts[0]; 631 $area = $parts[1]; 632 633 if (strpos($component, 'core') === 0) { 634 $plugin = 'core_search'; 635 $configprefix = str_replace('-', '_', $areaid); 636 } else { 637 $plugin = $component; 638 $configprefix = 'search_' . $area; 639 } 640 641 return [$plugin, $configprefix]; 642 } 643 644 /** 645 * Returns information about the areas which the user can access. 646 * 647 * The returned value is a stdClass object with the following fields: 648 * - everything (bool, true for admin only) 649 * - usercontexts (indexed by area identifier then context 650 * - separategroupscontexts (contexts within which group restrictions apply) 651 * - visiblegroupscontextsareas (overrides to the above when the same contexts also have 652 * 'visible groups' for certain search area ids - hopefully rare) 653 * - usergroups (groups which the current user belongs to) 654 * 655 * The areas can be limited by course id and context id. If specifying context ids, results 656 * are limited to the exact context ids specified and not their children (for example, giving 657 * the course context id would result in including search items with the course context id, and 658 * not anything from a context inside the course). For performance, you should also specify 659 * course id(s) when using context ids. 660 * 661 * @param array|false $limitcourseids An array of course ids to limit the search to. False for no limiting. 662 * @param array|false $limitcontextids An array of context ids to limit the search to. False for no limiting. 663 * @return \stdClass Object as described above 664 */ 665 protected function get_areas_user_accesses($limitcourseids = false, $limitcontextids = false) { 666 global $DB, $USER; 667 668 // All results for admins (unless they have chosen to limit results). Eventually we could 669 // add a new capability for managers. 670 if (is_siteadmin() && !$limitcourseids && !$limitcontextids) { 671 return (object)array('everything' => true); 672 } 673 674 $areasbylevel = array(); 675 676 // Split areas by context level so we only iterate only once through courses and cms. 677 $searchareas = static::get_search_areas_list(true); 678 foreach ($searchareas as $areaid => $unused) { 679 $classname = static::get_area_classname($areaid); 680 $searcharea = new $classname(); 681 foreach ($classname::get_levels() as $level) { 682 $areasbylevel[$level][$areaid] = $searcharea; 683 } 684 } 685 686 // This will store area - allowed contexts relations. 687 $areascontexts = array(); 688 689 // Initialise two special-case arrays for storing other information related to the contexts. 690 $separategroupscontexts = array(); 691 $visiblegroupscontextsareas = array(); 692 $usergroups = array(); 693 694 if (empty($limitcourseids) && !empty($areasbylevel[CONTEXT_SYSTEM])) { 695 // We add system context to all search areas working at this level. Here each area is fully responsible of 696 // the access control as we can not automate much, we can not even check guest access as some areas might 697 // want to allow guests to retrieve data from them. 698 699 $systemcontextid = \context_system::instance()->id; 700 if (!$limitcontextids || in_array($systemcontextid, $limitcontextids)) { 701 foreach ($areasbylevel[CONTEXT_SYSTEM] as $areaid => $searchclass) { 702 $areascontexts[$areaid][$systemcontextid] = $systemcontextid; 703 } 704 } 705 } 706 707 if (!empty($areasbylevel[CONTEXT_USER])) { 708 if ($usercontext = \context_user::instance($USER->id, IGNORE_MISSING)) { 709 if (!$limitcontextids || in_array($usercontext->id, $limitcontextids)) { 710 // Extra checking although only logged users should reach this point, guest users have a valid context id. 711 foreach ($areasbylevel[CONTEXT_USER] as $areaid => $searchclass) { 712 $areascontexts[$areaid][$usercontext->id] = $usercontext->id; 713 } 714 } 715 } 716 } 717 718 if (is_siteadmin()) { 719 $allcourses = $this->get_all_courses($limitcourseids); 720 } else { 721 $allcourses = $mycourses = $this->get_my_courses((bool)get_config('core', 'searchallavailablecourses')); 722 723 if (self::include_all_courses()) { 724 $allcourses = $this->get_all_courses($limitcourseids); 725 } 726 } 727 728 if (empty($limitcourseids) || in_array(SITEID, $limitcourseids)) { 729 $allcourses[SITEID] = get_course(SITEID); 730 if (isset($mycourses)) { 731 $mycourses[SITEID] = get_course(SITEID); 732 } 733 } 734 735 // Keep a list of included course context ids (needed for the block calculation below). 736 $coursecontextids = []; 737 $modulecms = []; 738 739 foreach ($allcourses as $course) { 740 if (!empty($limitcourseids) && !in_array($course->id, $limitcourseids)) { 741 // Skip non-included courses. 742 continue; 743 } 744 745 $coursecontext = \context_course::instance($course->id); 746 $hasgrouprestrictions = false; 747 748 if (!empty($areasbylevel[CONTEXT_COURSE]) && 749 (!$limitcontextids || in_array($coursecontext->id, $limitcontextids))) { 750 // Add the course contexts the user can view. 751 foreach ($areasbylevel[CONTEXT_COURSE] as $areaid => $searchclass) { 752 if (!empty($mycourses[$course->id]) || \core_course_category::can_view_course_info($course)) { 753 $areascontexts[$areaid][$coursecontext->id] = $coursecontext->id; 754 } 755 } 756 } 757 758 // Skip module context if a user can't access related course. 759 if (isset($mycourses) && !key_exists($course->id, $mycourses)) { 760 continue; 761 } 762 763 $coursecontextids[] = $coursecontext->id; 764 765 // Info about the course modules. 766 $modinfo = get_fast_modinfo($course); 767 768 if (!empty($areasbylevel[CONTEXT_MODULE])) { 769 // Add the module contexts the user can view (cm_info->uservisible). 770 771 foreach ($areasbylevel[CONTEXT_MODULE] as $areaid => $searchclass) { 772 773 // Removing the plugintype 'mod_' prefix. 774 $modulename = substr($searchclass->get_component_name(), 4); 775 776 $modinstances = $modinfo->get_instances_of($modulename); 777 foreach ($modinstances as $modinstance) { 778 // Skip module context if not included in list of context ids. 779 if ($limitcontextids && !in_array($modinstance->context->id, $limitcontextids)) { 780 continue; 781 } 782 if ($modinstance->uservisible) { 783 $contextid = $modinstance->context->id; 784 $areascontexts[$areaid][$contextid] = $contextid; 785 $modulecms[$modinstance->id] = $modinstance; 786 787 if (!has_capability('moodle/site:accessallgroups', $modinstance->context) && 788 ($searchclass instanceof base_mod) && 789 $searchclass->supports_group_restriction()) { 790 if ($searchclass->restrict_cm_access_by_group($modinstance)) { 791 $separategroupscontexts[$contextid] = $contextid; 792 $hasgrouprestrictions = true; 793 } else { 794 // Track a list of anything that has a group id (so might get 795 // filtered) and doesn't want to be, in this context. 796 if (!array_key_exists($contextid, $visiblegroupscontextsareas)) { 797 $visiblegroupscontextsareas[$contextid] = array(); 798 } 799 $visiblegroupscontextsareas[$contextid][$areaid] = $areaid; 800 } 801 } 802 } 803 } 804 } 805 } 806 807 // Insert group information for course (unless there aren't any modules restricted by 808 // group for this user in this course, in which case don't bother). 809 if ($hasgrouprestrictions) { 810 $groups = groups_get_all_groups($course->id, $USER->id, 0, 'g.id'); 811 foreach ($groups as $group) { 812 $usergroups[$group->id] = $group->id; 813 } 814 } 815 } 816 817 // Chuck away all the 'visible groups contexts' data unless there is actually something 818 // that does use separate groups in the same context (this data is only used as an 819 // 'override' in cases where the search is restricting to separate groups). 820 foreach ($visiblegroupscontextsareas as $contextid => $areas) { 821 if (!array_key_exists($contextid, $separategroupscontexts)) { 822 unset($visiblegroupscontextsareas[$contextid]); 823 } 824 } 825 826 // Add all supported block contexts for course contexts that user can access, in a single query for performance. 827 if (!empty($areasbylevel[CONTEXT_BLOCK]) && !empty($coursecontextids)) { 828 // Get list of all block types we care about. 829 $blocklist = []; 830 foreach ($areasbylevel[CONTEXT_BLOCK] as $areaid => $searchclass) { 831 $blocklist[$searchclass->get_block_name()] = true; 832 } 833 list ($blocknamesql, $blocknameparams) = $DB->get_in_or_equal(array_keys($blocklist)); 834 835 // Get list of course contexts. 836 list ($contextsql, $contextparams) = $DB->get_in_or_equal($coursecontextids); 837 838 // Get list of block context (if limited). 839 $blockcontextwhere = ''; 840 $blockcontextparams = []; 841 if ($limitcontextids) { 842 list ($blockcontextsql, $blockcontextparams) = $DB->get_in_or_equal($limitcontextids); 843 $blockcontextwhere = 'AND x.id ' . $blockcontextsql; 844 } 845 846 // Query all blocks that are within an included course, and are set to be visible, and 847 // in a supported page type (basically just course view). This query could be 848 // extended (or a second query added) to support blocks that are within a module 849 // context as well, and we could add more page types if required. 850 $blockrecs = $DB->get_records_sql(" 851 SELECT x.*, bi.blockname AS blockname, bi.id AS blockinstanceid 852 FROM {block_instances} bi 853 JOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ? 854 LEFT JOIN {block_positions} bp ON bp.blockinstanceid = bi.id 855 AND bp.contextid = bi.parentcontextid 856 AND bp.pagetype LIKE 'course-view-%' 857 AND bp.subpage = '' 858 AND bp.visible = 0 859 WHERE bi.parentcontextid $contextsql 860 $blockcontextwhere 861 AND bi.blockname $blocknamesql 862 AND bi.subpagepattern IS NULL 863 AND (bi.pagetypepattern = 'site-index' 864 OR bi.pagetypepattern LIKE 'course-view-%' 865 OR bi.pagetypepattern = 'course-*' 866 OR bi.pagetypepattern = '*') 867 AND bp.id IS NULL", 868 array_merge([CONTEXT_BLOCK], $contextparams, $blockcontextparams, $blocknameparams)); 869 $blockcontextsbyname = []; 870 foreach ($blockrecs as $blockrec) { 871 if (empty($blockcontextsbyname[$blockrec->blockname])) { 872 $blockcontextsbyname[$blockrec->blockname] = []; 873 } 874 \context_helper::preload_from_record($blockrec); 875 $blockcontextsbyname[$blockrec->blockname][] = \context_block::instance( 876 $blockrec->blockinstanceid); 877 } 878 879 // Add the block contexts the user can view. 880 foreach ($areasbylevel[CONTEXT_BLOCK] as $areaid => $searchclass) { 881 if (empty($blockcontextsbyname[$searchclass->get_block_name()])) { 882 continue; 883 } 884 foreach ($blockcontextsbyname[$searchclass->get_block_name()] as $context) { 885 if (has_capability('moodle/block:view', $context)) { 886 $areascontexts[$areaid][$context->id] = $context->id; 887 } 888 } 889 } 890 } 891 892 // Return all the data. 893 return (object)array('everything' => false, 'usercontexts' => $areascontexts, 894 'separategroupscontexts' => $separategroupscontexts, 'usergroups' => $usergroups, 895 'visiblegroupscontextsareas' => $visiblegroupscontextsareas); 896 } 897 898 /** 899 * Returns requested page of documents plus additional information for paging. 900 * 901 * This function does not perform any kind of security checking for access, the caller code 902 * should check that the current user have moodle/search:query capability. 903 * 904 * If a page is requested that is beyond the last result, the last valid page is returned in 905 * results, and actualpage indicates which page was returned. 906 * 907 * @param stdClass $formdata 908 * @param int $pagenum The 0 based page number. 909 * @return object An object with 3 properties: 910 * results => An array of \core_search\documents for the actual page. 911 * totalcount => Number of records that are possibly available, to base paging on. 912 * actualpage => The actual page returned. 913 */ 914 public function paged_search(\stdClass $formdata, $pagenum) { 915 $out = new \stdClass(); 916 917 if (self::is_search_area_categories_enabled() && !empty($formdata->cat)) { 918 $cat = self::get_search_area_category_by_name($formdata->cat); 919 if (empty($formdata->areaids)) { 920 $formdata->areaids = array_keys($cat->get_areas()); 921 } else { 922 foreach ($formdata->areaids as $key => $areaid) { 923 if (!key_exists($areaid, $cat->get_areas())) { 924 unset($formdata->areaids[$key]); 925 } 926 } 927 } 928 } 929 930 $perpage = static::DISPLAY_RESULTS_PER_PAGE; 931 932 // Make sure we only allow request up to max page. 933 $pagenum = min($pagenum, (static::MAX_RESULTS / $perpage) - 1); 934 935 // Calculate the first and last document number for the current page, 1 based. 936 $mindoc = ($pagenum * $perpage) + 1; 937 $maxdoc = ($pagenum + 1) * $perpage; 938 939 // Get engine documents, up to max. 940 $docs = $this->search($formdata, $maxdoc); 941 942 $resultcount = count($docs); 943 if ($resultcount < $maxdoc) { 944 // This means it couldn't give us results to max, so the count must be the max. 945 $out->totalcount = $resultcount; 946 } else { 947 // Get the possible count reported by engine, and limit to our max. 948 $out->totalcount = $this->engine->get_query_total_count(); 949 if (defined('BEHAT_SITE_RUNNING') && $this->behatresultcount) { 950 // Override results when using Behat mock results. 951 $out->totalcount = $this->behatresultcount; 952 } 953 $out->totalcount = min($out->totalcount, static::MAX_RESULTS); 954 } 955 956 // Determine the actual page. 957 if ($resultcount < $mindoc) { 958 // We couldn't get the min docs for this page, so determine what page we can get. 959 $out->actualpage = floor(($resultcount - 1) / $perpage); 960 } else { 961 $out->actualpage = $pagenum; 962 } 963 964 // Split the results to only return the page. 965 $out->results = array_slice($docs, $out->actualpage * $perpage, $perpage, true); 966 967 return $out; 968 } 969 970 /** 971 * Returns documents from the engine based on the data provided. 972 * 973 * This function does not perform any kind of security checking, the caller code 974 * should check that the current user have moodle/search:query capability. 975 * 976 * It might return the results from the cache instead. 977 * 978 * Valid formdata options include: 979 * - q (query text) 980 * - courseids (optional list of course ids to restrict) 981 * - contextids (optional list of context ids to restrict) 982 * - context (Moodle context object for location user searched from) 983 * - order (optional ordering, one of the types supported by the search engine e.g. 'relevance') 984 * - userids (optional list of user ids to restrict) 985 * 986 * @param \stdClass $formdata Query input data (usually from search form) 987 * @param int $limit The maximum number of documents to return 988 * @return \core_search\document[] 989 */ 990 public function search(\stdClass $formdata, $limit = 0) { 991 // For Behat testing, the search results can be faked using a special step. 992 if (defined('BEHAT_SITE_RUNNING')) { 993 $fakeresult = get_config('core_search', 'behat_fakeresult'); 994 if ($fakeresult) { 995 // Clear config setting. 996 unset_config('core_search', 'behat_fakeresult'); 997 998 // Check query matches expected value. 999 $details = json_decode($fakeresult); 1000 if ($formdata->q !== $details->query) { 1001 throw new \coding_exception('Unexpected search query: ' . $formdata->q); 1002 } 1003 1004 // Create search documents from the JSON data. 1005 $docs = []; 1006 foreach ($details->results as $result) { 1007 $doc = new \core_search\document($result->itemid, $result->componentname, 1008 $result->areaname); 1009 foreach ((array)$result->fields as $field => $value) { 1010 $doc->set($field, $value); 1011 } 1012 foreach ((array)$result->extrafields as $field => $value) { 1013 $doc->set_extra($field, $value); 1014 } 1015 $area = $this->get_search_area($doc->get('areaid')); 1016 $doc->set_doc_url($area->get_doc_url($doc)); 1017 $doc->set_context_url($area->get_context_url($doc)); 1018 $docs[] = $doc; 1019 } 1020 1021 // Store the mock count, and apply the limit to the returned results. 1022 $this->behatresultcount = count($docs); 1023 if ($this->behatresultcount > $limit) { 1024 $docs = array_slice($docs, 0, $limit); 1025 } 1026 1027 return $docs; 1028 } 1029 } 1030 1031 $limitcourseids = $this->build_limitcourseids($formdata); 1032 1033 $limitcontextids = false; 1034 if (!empty($formdata->contextids)) { 1035 $limitcontextids = $formdata->contextids; 1036 } 1037 1038 // Clears previous query errors. 1039 $this->engine->clear_query_error(); 1040 1041 $contextinfo = $this->get_areas_user_accesses($limitcourseids, $limitcontextids); 1042 if (!$contextinfo->everything && !$contextinfo->usercontexts) { 1043 // User can not access any context. 1044 $docs = array(); 1045 } else { 1046 // If engine does not support groups, remove group information from the context info - 1047 // use the old format instead (true = admin, array = user contexts). 1048 if (!$this->engine->supports_group_filtering()) { 1049 $contextinfo = $contextinfo->everything ? true : $contextinfo->usercontexts; 1050 } 1051 1052 // Execute the actual query. 1053 $docs = $this->engine->execute_query($formdata, $contextinfo, $limit); 1054 } 1055 1056 return $docs; 1057 } 1058 1059 /** 1060 * Build a list of course ids to limit the search based on submitted form data. 1061 * 1062 * @param \stdClass $formdata Submitted search form data. 1063 * 1064 * @return array|bool 1065 */ 1066 protected function build_limitcourseids(\stdClass $formdata) { 1067 $limitcourseids = false; 1068 1069 if (!empty($formdata->mycoursesonly)) { 1070 $limitcourseids = array_keys($this->get_my_courses(false)); 1071 } 1072 1073 if (!empty($formdata->courseids)) { 1074 if (empty($limitcourseids)) { 1075 $limitcourseids = $formdata->courseids; 1076 } else { 1077 $limitcourseids = array_intersect($limitcourseids, $formdata->courseids); 1078 } 1079 } 1080 1081 return $limitcourseids; 1082 } 1083 1084 /** 1085 * Merge separate index segments into one. 1086 */ 1087 public function optimize_index() { 1088 $this->engine->optimize(); 1089 } 1090 1091 /** 1092 * Index all documents. 1093 * 1094 * @param bool $fullindex Whether we should reindex everything or not. 1095 * @param float $timelimit Time limit in seconds (0 = no time limit) 1096 * @param \progress_trace|null $progress Optional class for tracking progress 1097 * @throws \moodle_exception 1098 * @return bool Whether there was any updated document or not. 1099 */ 1100 public function index($fullindex = false, $timelimit = 0, \progress_trace $progress = null) { 1101 global $DB; 1102 1103 // Cannot combine time limit with reindex. 1104 if ($timelimit && $fullindex) { 1105 throw new \coding_exception('Cannot apply time limit when reindexing'); 1106 } 1107 if (!$progress) { 1108 $progress = new \null_progress_trace(); 1109 } 1110 1111 // Unlimited time. 1112 \core_php_time_limit::raise(); 1113 1114 // Notify the engine that an index starting. 1115 $this->engine->index_starting($fullindex); 1116 1117 $sumdocs = 0; 1118 1119 $searchareas = $this->get_search_areas_list(true); 1120 1121 if ($timelimit) { 1122 // If time is limited (and therefore we're not just indexing everything anyway), select 1123 // an order for search areas. The intention here is to avoid a situation where a new 1124 // large search area is enabled, and this means all our other search areas go out of 1125 // date while that one is being indexed. To do this, we order by the time we spent 1126 // indexing them last time we ran, meaning anything that took a very long time will be 1127 // done last. 1128 uasort($searchareas, function(\core_search\base $area1, \core_search\base $area2) { 1129 return (int)$area1->get_last_indexing_duration() - (int)$area2->get_last_indexing_duration(); 1130 }); 1131 1132 // Decide time to stop. 1133 $stopat = self::get_current_time() + $timelimit; 1134 } 1135 1136 foreach ($searchareas as $areaid => $searcharea) { 1137 1138 $progress->output('Processing area: ' . $searcharea->get_visible_name()); 1139 1140 // Notify the engine that an area is starting. 1141 $this->engine->area_index_starting($searcharea, $fullindex); 1142 1143 $indexingstart = (int)self::get_current_time(); 1144 $elapsed = self::get_current_time(); 1145 1146 // This is used to store this component config. 1147 list($componentconfigname, $varname) = $searcharea->get_config_var_name(); 1148 1149 $prevtimestart = intval(get_config($componentconfigname, $varname . '_indexingstart')); 1150 1151 if ($fullindex === true) { 1152 $referencestarttime = 0; 1153 1154 // For full index, we delete any queued context index requests, as those will 1155 // obviously be met by the full index. 1156 $DB->delete_records('search_index_requests'); 1157 } else { 1158 $partial = get_config($componentconfigname, $varname . '_partial'); 1159 if ($partial) { 1160 // When the previous index did not complete all data, we start from the time of the 1161 // last document that was successfully indexed. (Note this will result in 1162 // re-indexing that one document, but we can't avoid that because there may be 1163 // other documents in the same second.) 1164 $referencestarttime = intval(get_config($componentconfigname, $varname . '_lastindexrun')); 1165 } else { 1166 $referencestarttime = $prevtimestart; 1167 } 1168 } 1169 1170 // Getting the recordset from the area. 1171 $recordset = $searcharea->get_recordset_by_timestamp($referencestarttime); 1172 $initialquerytime = self::get_current_time() - $elapsed; 1173 if ($initialquerytime > self::DISPLAY_LONG_QUERY_TIME) { 1174 $progress->output('Initial query took ' . round($initialquerytime, 1) . 1175 ' seconds.', 1); 1176 } 1177 1178 // Pass get_document as callback. 1179 $fileindexing = $this->engine->file_indexing_enabled() && $searcharea->uses_file_indexing(); 1180 $options = array('indexfiles' => $fileindexing, 'lastindexedtime' => $prevtimestart); 1181 if ($timelimit) { 1182 $options['stopat'] = $stopat; 1183 } 1184 $options['progress'] = $progress; 1185 $iterator = new skip_future_documents_iterator(new \core\dml\recordset_walk( 1186 $recordset, array($searcharea, 'get_document'), $options)); 1187 $result = $this->engine->add_documents($iterator, $searcharea, $options); 1188 $recordset->close(); 1189 $batchinfo = ''; 1190 if (count($result) === 6) { 1191 [$numrecords, $numdocs, $numdocsignored, $lastindexeddoc, $partial, $batches] = $result; 1192 // Only show the batch count if we actually batched any requests. 1193 if ($batches !== $numdocs + $numdocsignored) { 1194 $batchinfo = ' (' . $batches . ' batch' . ($batches === 1 ? '' : 'es') . ')'; 1195 } 1196 } else if (count($result) === 5) { 1197 // Backward compatibility for engines that don't return a batch count. 1198 [$numrecords, $numdocs, $numdocsignored, $lastindexeddoc, $partial] = $result; 1199 // Deprecated since Moodle 3.10 MDL-68690. 1200 // TODO: MDL-68776 This will be deleted in Moodle 4.2. 1201 debugging('engine::add_documents() should return $batches (5-value return is deprecated)', 1202 DEBUG_DEVELOPER); 1203 } else { 1204 throw new coding_exception('engine::add_documents() should return $partial (4-value return is deprecated)'); 1205 } 1206 1207 if ($numdocs > 0) { 1208 $elapsed = round((self::get_current_time() - $elapsed), 1); 1209 1210 $partialtext = ''; 1211 if ($partial) { 1212 $partialtext = ' (not complete; done to ' . userdate($lastindexeddoc, 1213 get_string('strftimedatetimeshort', 'langconfig')) . ')'; 1214 } 1215 1216 $progress->output('Processed ' . $numrecords . ' records containing ' . $numdocs . 1217 ' documents' . $batchinfo . ', in ' . $elapsed . ' seconds' . $partialtext . '.', 1); 1218 } else { 1219 $progress->output('No new documents to index.', 1); 1220 } 1221 1222 // Notify the engine this area is complete, and only mark times if true. 1223 if ($this->engine->area_index_complete($searcharea, $numdocs, $fullindex)) { 1224 $sumdocs += $numdocs; 1225 1226 // Store last index run once documents have been committed to the search engine. 1227 set_config($varname . '_indexingstart', $indexingstart, $componentconfigname); 1228 set_config($varname . '_indexingend', (int)self::get_current_time(), $componentconfigname); 1229 set_config($varname . '_docsignored', $numdocsignored, $componentconfigname); 1230 set_config($varname . '_docsprocessed', $numdocs, $componentconfigname); 1231 set_config($varname . '_recordsprocessed', $numrecords, $componentconfigname); 1232 if ($lastindexeddoc > 0) { 1233 set_config($varname . '_lastindexrun', $lastindexeddoc, $componentconfigname); 1234 } 1235 if ($partial) { 1236 set_config($varname . '_partial', 1, $componentconfigname); 1237 } else { 1238 unset_config($varname . '_partial', $componentconfigname); 1239 } 1240 } else { 1241 $progress->output('Engine reported error.'); 1242 } 1243 1244 if ($timelimit && (self::get_current_time() >= $stopat)) { 1245 $progress->output('Stopping indexing due to time limit.'); 1246 break; 1247 } 1248 } 1249 1250 if ($sumdocs > 0) { 1251 $event = \core\event\search_indexed::create( 1252 array('context' => \context_system::instance())); 1253 $event->trigger(); 1254 } 1255 1256 $this->engine->index_complete($sumdocs, $fullindex); 1257 1258 return (bool)$sumdocs; 1259 } 1260 1261 /** 1262 * Indexes or reindexes a specific context of the system, e.g. one course. 1263 * 1264 * The function returns an object with field 'complete' (true or false). 1265 * 1266 * This function supports partial indexing via the time limit parameter. If the time limit 1267 * expires, it will return values for $startfromarea and $startfromtime which can be passed 1268 * next time to continue indexing. 1269 * 1270 * @param \context $context Context to restrict index. 1271 * @param string $singleareaid If specified, indexes only the given area. 1272 * @param float $timelimit Time limit in seconds (0 = no time limit) 1273 * @param \progress_trace|null $progress Optional class for tracking progress 1274 * @param string $startfromarea Area to start from 1275 * @param int $startfromtime Timestamp to start from 1276 * @return \stdClass Object indicating success 1277 */ 1278 public function index_context($context, $singleareaid = '', $timelimit = 0, 1279 \progress_trace $progress = null, $startfromarea = '', $startfromtime = 0) { 1280 if (!$progress) { 1281 $progress = new \null_progress_trace(); 1282 } 1283 1284 // Work out time to stop, if limited. 1285 if ($timelimit) { 1286 // Decide time to stop. 1287 $stopat = self::get_current_time() + $timelimit; 1288 } 1289 1290 // No PHP time limit. 1291 \core_php_time_limit::raise(); 1292 1293 // Notify the engine that an index starting. 1294 $this->engine->index_starting(false); 1295 1296 $sumdocs = 0; 1297 1298 // Get all search areas, in consistent order. 1299 $searchareas = $this->get_search_areas_list(true); 1300 ksort($searchareas); 1301 1302 // Are we skipping past some that were handled previously? 1303 $skipping = $startfromarea ? true : false; 1304 1305 foreach ($searchareas as $areaid => $searcharea) { 1306 // If we're only processing one area id, skip all the others. 1307 if ($singleareaid && $singleareaid !== $areaid) { 1308 continue; 1309 } 1310 1311 // If we're skipping to a later area, continue through the loop. 1312 $referencestarttime = 0; 1313 if ($skipping) { 1314 if ($areaid !== $startfromarea) { 1315 continue; 1316 } 1317 // Stop skipping and note the reference start time. 1318 $skipping = false; 1319 $referencestarttime = $startfromtime; 1320 } 1321 1322 $progress->output('Processing area: ' . $searcharea->get_visible_name()); 1323 1324 $elapsed = self::get_current_time(); 1325 1326 // Get the recordset of all documents from the area for this context. 1327 $recordset = $searcharea->get_document_recordset($referencestarttime, $context); 1328 if (!$recordset) { 1329 if ($recordset === null) { 1330 $progress->output('Skipping (not relevant to context).', 1); 1331 } else { 1332 $progress->output('Skipping (does not support context indexing).', 1); 1333 } 1334 continue; 1335 } 1336 1337 // Notify the engine that an area is starting. 1338 $this->engine->area_index_starting($searcharea, false); 1339 1340 // Work out search options. 1341 $options = []; 1342 $options['indexfiles'] = $this->engine->file_indexing_enabled() && 1343 $searcharea->uses_file_indexing(); 1344 if ($timelimit) { 1345 $options['stopat'] = $stopat; 1346 } 1347 1348 // Construct iterator which will use get_document on the recordset results. 1349 $iterator = new \core\dml\recordset_walk($recordset, 1350 array($searcharea, 'get_document'), $options); 1351 1352 // Use this iterator to add documents. 1353 $result = $this->engine->add_documents($iterator, $searcharea, $options); 1354 $batchinfo = ''; 1355 if (count($result) === 6) { 1356 [$numrecords, $numdocs, $numdocsignored, $lastindexeddoc, $partial, $batches] = $result; 1357 // Only show the batch count if we actually batched any requests. 1358 if ($batches !== $numdocs + $numdocsignored) { 1359 $batchinfo = ' (' . $batches . ' batch' . ($batches === 1 ? '' : 'es') . ')'; 1360 } 1361 } else if (count($result) === 5) { 1362 // Backward compatibility for engines that don't return a batch count. 1363 [$numrecords, $numdocs, $numdocsignored, $lastindexeddoc, $partial] = $result; 1364 // Deprecated since Moodle 3.10 MDL-68690. 1365 // TODO: MDL-68776 This will be deleted in Moodle 4.2 (as should the below bit). 1366 debugging('engine::add_documents() should return $batches (5-value return is deprecated)', 1367 DEBUG_DEVELOPER); 1368 } else { 1369 // Backward compatibility for engines that don't support partial adding. 1370 list($numrecords, $numdocs, $numdocsignored, $lastindexeddoc) = $result; 1371 debugging('engine::add_documents() should return $partial (4-value return is deprecated)', 1372 DEBUG_DEVELOPER); 1373 $partial = false; 1374 } 1375 1376 if ($numdocs > 0) { 1377 $elapsed = round((self::get_current_time() - $elapsed), 3); 1378 $progress->output('Processed ' . $numrecords . ' records containing ' . $numdocs . 1379 ' documents' . $batchinfo . ', in ' . $elapsed . ' seconds' . 1380 ($partial ? ' (not complete)' : '') . '.', 1); 1381 } else { 1382 $progress->output('No documents to index.', 1); 1383 } 1384 1385 // Notify the engine this area is complete, but don't store any times as this is not 1386 // part of the 'normal' search index. 1387 if (!$this->engine->area_index_complete($searcharea, $numdocs, false)) { 1388 $progress->output('Engine reported error.', 1); 1389 } 1390 1391 if ($partial && $timelimit && (self::get_current_time() >= $stopat)) { 1392 $progress->output('Stopping indexing due to time limit.'); 1393 break; 1394 } 1395 } 1396 1397 if ($sumdocs > 0) { 1398 $event = \core\event\search_indexed::create( 1399 array('context' => $context)); 1400 $event->trigger(); 1401 } 1402 1403 $this->engine->index_complete($sumdocs, false); 1404 1405 // Indicate in result whether we completed indexing, or only part of it. 1406 $result = new \stdClass(); 1407 if ($partial) { 1408 $result->complete = false; 1409 $result->startfromarea = $areaid; 1410 $result->startfromtime = $lastindexeddoc; 1411 } else { 1412 $result->complete = true; 1413 } 1414 return $result; 1415 } 1416 1417 /** 1418 * Resets areas config. 1419 * 1420 * @throws \moodle_exception 1421 * @param string $areaid 1422 * @return void 1423 */ 1424 public function reset_config($areaid = false) { 1425 1426 if (!empty($areaid)) { 1427 $searchareas = array(); 1428 if (!$searchareas[$areaid] = static::get_search_area($areaid)) { 1429 throw new \moodle_exception('errorareanotavailable', 'search', '', $areaid); 1430 } 1431 } else { 1432 // Only the enabled ones. 1433 $searchareas = static::get_search_areas_list(true); 1434 } 1435 1436 foreach ($searchareas as $searcharea) { 1437 list($componentname, $varname) = $searcharea->get_config_var_name(); 1438 $config = $searcharea->get_config(); 1439 1440 foreach ($config as $key => $value) { 1441 // We reset them all but the enable/disabled one. 1442 if ($key !== $varname . '_enabled') { 1443 set_config($key, 0, $componentname); 1444 } 1445 } 1446 } 1447 } 1448 1449 /** 1450 * Deletes an area's documents or all areas documents. 1451 * 1452 * @param string $areaid The area id or false for all 1453 * @return void 1454 */ 1455 public function delete_index($areaid = false) { 1456 if (!empty($areaid)) { 1457 $this->engine->delete($areaid); 1458 $this->reset_config($areaid); 1459 } else { 1460 $this->engine->delete(); 1461 $this->reset_config(); 1462 } 1463 } 1464 1465 /** 1466 * Deletes index by id. 1467 * 1468 * @param int Solr Document string $id 1469 */ 1470 public function delete_index_by_id($id) { 1471 $this->engine->delete_by_id($id); 1472 } 1473 1474 /** 1475 * Returns search areas configuration. 1476 * 1477 * @param \core_search\base[] $searchareas 1478 * @return \stdClass[] $configsettings 1479 */ 1480 public function get_areas_config($searchareas) { 1481 1482 $vars = array('indexingstart', 'indexingend', 'lastindexrun', 'docsignored', 1483 'docsprocessed', 'recordsprocessed', 'partial'); 1484 1485 $configsettings = []; 1486 foreach ($searchareas as $searcharea) { 1487 1488 $areaid = $searcharea->get_area_id(); 1489 1490 $configsettings[$areaid] = new \stdClass(); 1491 list($componentname, $varname) = $searcharea->get_config_var_name(); 1492 1493 if (!$searcharea->is_enabled()) { 1494 // We delete all indexed data on disable so no info. 1495 foreach ($vars as $var) { 1496 $configsettings[$areaid]->{$var} = 0; 1497 } 1498 } else { 1499 foreach ($vars as $var) { 1500 $configsettings[$areaid]->{$var} = get_config($componentname, $varname .'_' . $var); 1501 } 1502 } 1503 1504 // Formatting the time. 1505 if (!empty($configsettings[$areaid]->lastindexrun)) { 1506 $configsettings[$areaid]->lastindexrun = userdate($configsettings[$areaid]->lastindexrun); 1507 } else { 1508 $configsettings[$areaid]->lastindexrun = get_string('never'); 1509 } 1510 } 1511 return $configsettings; 1512 } 1513 1514 /** 1515 * Triggers search_results_viewed event 1516 * 1517 * Other data required: 1518 * - q: The query string 1519 * - page: The page number 1520 * - title: Title filter 1521 * - areaids: Search areas filter 1522 * - courseids: Courses filter 1523 * - timestart: Time start filter 1524 * - timeend: Time end filter 1525 * 1526 * @since Moodle 3.2 1527 * @param array $other Other info for the event. 1528 * @return \core\event\search_results_viewed 1529 */ 1530 public static function trigger_search_results_viewed($other) { 1531 $event = \core\event\search_results_viewed::create([ 1532 'context' => \context_system::instance(), 1533 'other' => $other 1534 ]); 1535 $event->trigger(); 1536 1537 return $event; 1538 } 1539 1540 /** 1541 * Checks whether a classname is of an actual search area. 1542 * 1543 * @param string $classname 1544 * @return bool 1545 */ 1546 protected static function is_search_area($classname) { 1547 if (is_subclass_of($classname, 'core_search\base')) { 1548 return (new \ReflectionClass($classname))->isInstantiable(); 1549 } 1550 1551 return false; 1552 } 1553 1554 /** 1555 * Requests that a specific context is indexed by the scheduled task. The context will be 1556 * added to a queue which is processed by the task. 1557 * 1558 * This is used after a restore to ensure that restored items are indexed, even though their 1559 * modified time will be older than the latest indexed. It is also used by the 'Gradual reindex' 1560 * admin feature from the search areas screen. 1561 * 1562 * @param \context $context Context to index within 1563 * @param string $areaid Area to index, '' = all areas 1564 * @param int $priority Priority (INDEX_PRIORITY_xx constant) 1565 */ 1566 public static function request_index(\context $context, $areaid = '', 1567 $priority = self::INDEX_PRIORITY_NORMAL) { 1568 global $DB; 1569 1570 // Check through existing requests for this context or any parent context. 1571 list ($contextsql, $contextparams) = $DB->get_in_or_equal( 1572 $context->get_parent_context_ids(true)); 1573 $existing = $DB->get_records_select('search_index_requests', 1574 'contextid ' . $contextsql, $contextparams, '', 1575 'id, searcharea, partialarea, indexpriority'); 1576 foreach ($existing as $rec) { 1577 // If we haven't started processing the existing request yet, and it covers the same 1578 // area (or all areas) then that will be sufficient so don't add anything else. 1579 if ($rec->partialarea === '' && ($rec->searcharea === $areaid || $rec->searcharea === '')) { 1580 // If the existing request has the same (or higher) priority, no need to add anything. 1581 if ($rec->indexpriority >= $priority) { 1582 return; 1583 } 1584 // The existing request has lower priority. If it is exactly the same, then just 1585 // adjust the priority of the existing request. 1586 if ($rec->searcharea === $areaid) { 1587 $DB->set_field('search_index_requests', 'indexpriority', $priority, 1588 ['id' => $rec->id]); 1589 return; 1590 } 1591 // The existing request would cover this area but is a lower priority. We need to 1592 // add the new request even though that means we will index part of it twice. 1593 } 1594 } 1595 1596 // No suitable existing request, so add a new one. 1597 $newrecord = [ 'contextid' => $context->id, 'searcharea' => $areaid, 1598 'timerequested' => (int)self::get_current_time(), 1599 'partialarea' => '', 'partialtime' => 0, 1600 'indexpriority' => $priority ]; 1601 $DB->insert_record('search_index_requests', $newrecord); 1602 } 1603 1604 /** 1605 * Processes outstanding index requests. This will take the first item from the queue (taking 1606 * account the indexing priority) and process it, continuing until an optional time limit is 1607 * reached. 1608 * 1609 * If there are no index requests, the function will do nothing. 1610 * 1611 * @param float $timelimit Time limit (0 = none) 1612 * @param \progress_trace|null $progress Optional progress indicator 1613 */ 1614 public function process_index_requests($timelimit = 0.0, \progress_trace $progress = null) { 1615 global $DB; 1616 1617 if (!$progress) { 1618 $progress = new \null_progress_trace(); 1619 } 1620 1621 $before = self::get_current_time(); 1622 if ($timelimit) { 1623 $stopat = $before + $timelimit; 1624 } 1625 while (true) { 1626 // Retrieve first request, using fully defined ordering. 1627 $requests = $DB->get_records('search_index_requests', null, 1628 'indexpriority DESC, timerequested, contextid, searcharea', 1629 'id, contextid, searcharea, partialarea, partialtime', 0, 1); 1630 if (!$requests) { 1631 // If there are no more requests, stop. 1632 break; 1633 } 1634 $request = reset($requests); 1635 1636 // Calculate remaining time. 1637 $remainingtime = 0; 1638 $beforeindex = self::get_current_time(); 1639 if ($timelimit) { 1640 $remainingtime = $stopat - $beforeindex; 1641 1642 // If the time limit expired already, stop now. (Otherwise we might accidentally 1643 // index with no time limit or a negative time limit.) 1644 if ($remainingtime <= 0) { 1645 break; 1646 } 1647 } 1648 1649 // Show a message before each request, indicating what will be indexed. 1650 $context = \context::instance_by_id($request->contextid, IGNORE_MISSING); 1651 if (!$context) { 1652 $DB->delete_records('search_index_requests', ['id' => $request->id]); 1653 $progress->output('Skipped deleted context: ' . $request->contextid); 1654 continue; 1655 } 1656 $contextname = $context->get_context_name(); 1657 if ($request->searcharea) { 1658 $contextname .= ' (search area: ' . $request->searcharea . ')'; 1659 } 1660 $progress->output('Indexing requested context: ' . $contextname); 1661 1662 // Actually index the context. 1663 $result = $this->index_context($context, $request->searcharea, $remainingtime, 1664 $progress, $request->partialarea, $request->partialtime); 1665 1666 // Work out shared part of message. 1667 $endmessage = $contextname . ' (' . round(self::get_current_time() - $beforeindex, 1) . 's)'; 1668 1669 // Update database table and continue/stop as appropriate. 1670 if ($result->complete) { 1671 // If we completed the request, remove it from the table. 1672 $DB->delete_records('search_index_requests', ['id' => $request->id]); 1673 $progress->output('Completed requested context: ' . $endmessage); 1674 } else { 1675 // If we didn't complete the request, store the partial details (how far it got). 1676 $DB->update_record('search_index_requests', ['id' => $request->id, 1677 'partialarea' => $result->startfromarea, 1678 'partialtime' => $result->startfromtime]); 1679 $progress->output('Ending requested context: ' . $endmessage); 1680 1681 // The time limit must have expired, so stop looping. 1682 break; 1683 } 1684 } 1685 } 1686 1687 /** 1688 * Gets information about the request queue, in the form of a plain object suitable for passing 1689 * to a template for rendering. 1690 * 1691 * @return \stdClass Information about queued index requests 1692 */ 1693 public function get_index_requests_info() { 1694 global $DB; 1695 1696 $result = new \stdClass(); 1697 1698 $result->total = $DB->count_records('search_index_requests'); 1699 $result->topten = $DB->get_records('search_index_requests', null, 1700 'indexpriority DESC, timerequested, contextid, searcharea', 1701 'id, contextid, timerequested, searcharea, partialarea, partialtime, indexpriority', 1702 0, 10); 1703 foreach ($result->topten as $item) { 1704 $context = \context::instance_by_id($item->contextid); 1705 $item->contextlink = \html_writer::link($context->get_url(), 1706 s($context->get_context_name())); 1707 if ($item->searcharea) { 1708 $item->areaname = $this->get_search_area($item->searcharea)->get_visible_name(); 1709 } 1710 if ($item->partialarea) { 1711 $item->partialareaname = $this->get_search_area($item->partialarea)->get_visible_name(); 1712 } 1713 switch ($item->indexpriority) { 1714 case self::INDEX_PRIORITY_REINDEXING : 1715 $item->priorityname = get_string('priority_reindexing', 'search'); 1716 break; 1717 case self::INDEX_PRIORITY_NORMAL : 1718 $item->priorityname = get_string('priority_normal', 'search'); 1719 break; 1720 } 1721 } 1722 1723 // Normalise array indices. 1724 $result->topten = array_values($result->topten); 1725 1726 if ($result->total > 10) { 1727 $result->ellipsis = true; 1728 } 1729 1730 return $result; 1731 } 1732 1733 /** 1734 * Gets current time for use in search system. 1735 * 1736 * Note: This should be replaced with generic core functionality once possible (see MDL-60644). 1737 * 1738 * @return float Current time in seconds (with decimals) 1739 */ 1740 public static function get_current_time() { 1741 if (PHPUNIT_TEST && self::$phpunitfaketime) { 1742 return self::$phpunitfaketime; 1743 } 1744 return microtime(true); 1745 } 1746 1747 /** 1748 * Check if search area categories functionality is enabled. 1749 * 1750 * @return bool 1751 */ 1752 public static function is_search_area_categories_enabled() { 1753 return !empty(get_config('core', 'searchenablecategories')); 1754 } 1755 1756 /** 1757 * Check if all results category should be hidden. 1758 * 1759 * @return bool 1760 */ 1761 public static function should_hide_all_results_category() { 1762 return get_config('core', 'searchhideallcategory'); 1763 } 1764 1765 /** 1766 * Returns default search area category name. 1767 * 1768 * @return string 1769 */ 1770 public static function get_default_area_category_name() { 1771 $default = get_config('core', 'searchdefaultcategory'); 1772 1773 if (empty($default)) { 1774 $default = self::SEARCH_AREA_CATEGORY_ALL; 1775 } 1776 1777 if ($default == self::SEARCH_AREA_CATEGORY_ALL && self::should_hide_all_results_category()) { 1778 $default = self::SEARCH_AREA_CATEGORY_COURSE_CONTENT; 1779 } 1780 1781 return $default; 1782 } 1783 1784 /** 1785 * Get a list of all courses limited by ids if required. 1786 * 1787 * @param array|false $limitcourseids An array of course ids to limit the search to. False for no limiting. 1788 * @return array 1789 */ 1790 protected function get_all_courses($limitcourseids) { 1791 global $DB; 1792 1793 if ($limitcourseids) { 1794 list ($coursesql, $courseparams) = $DB->get_in_or_equal($limitcourseids); 1795 $coursesql = 'id ' . $coursesql; 1796 } else { 1797 $coursesql = ''; 1798 $courseparams = []; 1799 } 1800 1801 // Get courses using the same list of fields from enrol_get_my_courses. 1802 return $DB->get_records_select('course', $coursesql, $courseparams, '', 1803 'id, category, sortorder, shortname, fullname, idnumber, startdate, visible, ' . 1804 'groupmode, groupmodeforce, cacherev'); 1805 } 1806 1807 /** 1808 * Get a list of courses as user can access. 1809 * 1810 * @param bool $allaccessible Include courses user is not enrolled in, but can access. 1811 * @return array 1812 */ 1813 protected function get_my_courses($allaccessible) { 1814 return enrol_get_my_courses(array('id', 'cacherev'), 'id', 0, [], $allaccessible); 1815 } 1816 1817 /** 1818 * Check if search all courses setting is enabled. 1819 * 1820 * @return bool 1821 */ 1822 public static function include_all_courses() { 1823 return !empty(get_config('core', 'searchincludeallcourses')); 1824 } 1825 1826 /** 1827 * Cleans up non existing search area. 1828 * 1829 * 1. Remove all configs from {config_plugins} table. 1830 * 2. Delete all related indexed documents. 1831 * 1832 * @param string $areaid Search area id. 1833 */ 1834 public static function clean_up_non_existing_area($areaid) { 1835 global $DB; 1836 1837 if (!empty(self::get_search_area($areaid))) { 1838 throw new \coding_exception("Area $areaid exists. Please use appropriate search area class to manipulate the data."); 1839 } 1840 1841 $parts = self::parse_areaid($areaid); 1842 1843 $plugin = $parts[0]; 1844 $configprefix = $parts[1]; 1845 1846 foreach (base::get_settingnames() as $settingname) { 1847 $name = $configprefix. $settingname; 1848 $DB->delete_records('config_plugins', ['name' => $name, 'plugin' => $plugin]); 1849 } 1850 1851 $engine = self::instance()->get_engine(); 1852 $engine->delete($areaid); 1853 } 1854 1855 /** 1856 * Informs the search system that a context has been deleted. 1857 * 1858 * This will clear the data from the search index, where the search engine supports that. 1859 * 1860 * This function does not usually throw an exception (so as not to get in the way of the 1861 * context deletion finishing). 1862 * 1863 * This is called for all types of context deletion. 1864 * 1865 * @param \context $context Context object that has just been deleted 1866 */ 1867 public static function context_deleted(\context $context) { 1868 if (self::is_indexing_enabled()) { 1869 try { 1870 // Hold on, are we deleting a course? If so, and this context is part of the course, 1871 // then don't bother to send a delete because we delete the whole course at once 1872 // later. 1873 if (!empty(self::$coursedeleting)) { 1874 $coursecontext = $context->get_course_context(false); 1875 if ($coursecontext && array_key_exists($coursecontext->instanceid, self::$coursedeleting)) { 1876 // Skip further processing. 1877 return; 1878 } 1879 } 1880 1881 $engine = self::instance()->get_engine(); 1882 $engine->delete_index_for_context($context->id); 1883 } catch (\moodle_exception $e) { 1884 debugging('Error deleting search index data for context ' . $context->id . ': ' . $e->getMessage()); 1885 } 1886 } 1887 } 1888 1889 /** 1890 * Informs the search system that a course is about to be deleted. 1891 * 1892 * This prevents it from sending hundreds of 'delete context' updates for all the individual 1893 * contexts that are deleted. 1894 * 1895 * If you call this, you must call course_deleting_finish(). 1896 * 1897 * @param int $courseid Course id that is being deleted 1898 */ 1899 public static function course_deleting_start(int $courseid) { 1900 self::$coursedeleting[$courseid] = true; 1901 } 1902 1903 /** 1904 * Informs the search engine that a course has now been deleted. 1905 * 1906 * This causes the search engine to actually delete the index for the whole course. 1907 * 1908 * @param int $courseid Course id that no longer exists 1909 */ 1910 public static function course_deleting_finish(int $courseid) { 1911 if (!array_key_exists($courseid, self::$coursedeleting)) { 1912 // Show a debug warning. It doesn't actually matter very much, as we will now delete 1913 // the course data anyhow. 1914 debugging('course_deleting_start not called before deletion of ' . $courseid, DEBUG_DEVELOPER); 1915 } 1916 unset(self::$coursedeleting[$courseid]); 1917 1918 if (self::is_indexing_enabled()) { 1919 try { 1920 $engine = self::instance()->get_engine(); 1921 $engine->delete_index_for_course($courseid); 1922 } catch (\moodle_exception $e) { 1923 debugging('Error deleting search index data for course ' . $courseid . ': ' . $e->getMessage()); 1924 } 1925 } 1926 } 1927 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
