Search moodle.org's
Developer Documentation
Developer Documentation
See Release Notes
Long Term Support Release
- Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
- Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
- PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.
/search/classes/ -> manager.php (source)
Differences Between: [Versions 310 and 401] [Versions 311 and 401] [Versions 39 and 401] [Versions 401 and 402] [Versions 401 and 403]
Search subsystem manager.
| Copyright: | Prateek Sachan {@link http://prateeksachan.com} |
| License: | http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later |
| File Size: | 2023 lines (80 kb) |
| Included or required: | 0 times |
| Referenced: | 0 times |
| Includes or requires: | 0 files |
Defines 2 classes
manager:: (46 methods):
__construct()
instance()
is_global_search_enabled()
can_replace_course_search()
get_course_search_url()
is_indexing_enabled()
search_engine_instance()
search_engine_instance_from_setting()
get_engine()
get_area_classname()
get_search_area()
get_search_areas_list()
get_search_area_category_by_name()
get_search_area_categories()
get_core_search_area_categories()
get_additional_search_area_categories()
is_valid_area_category()
clear_static()
generate_areaid()
extract_areaid_parts()
parse_areaid()
get_areas_user_accesses()
paged_search()
search()
search_top()
build_limitcourseids()
optimize_index()
index()
index_context()
reset_config()
delete_index()
delete_index_by_id()
get_areas_config()
trigger_search_results_viewed()
is_search_area()
request_index()
process_index_requests()
get_index_requests_info()
get_current_time()
is_search_area_categories_enabled()
should_hide_all_results_category()
get_default_area_category_name()
get_all_courses()
get_my_courses()
include_all_courses()
clean_up_non_existing_area()
to:: (3 methods):
context_deleted()
course_deleting_start()
course_deleting_finish()
Search subsystem manager.
| __construct($engine) X-Ref |
| Constructor, use \core_search\manager::instance instead to get a class instance. param: \core_search\base The search engine to use |
| instance(bool $fast = false, bool $query = false) X-Ref |
| Returns an initialised \core_search instance. While constructing the instance, checks on the search schema may be carried out. The $fast parameter provides a way to skip those checks on pages which are used frequently. It has no effect if an instance has already been constructed in this request. The $query parameter indicates that the page is used for queries rather than indexing. If configured, this will cause the query-only search engine to be used instead of the 'normal' one. param: bool $fast Set to true when calling on a page that requires high performance param: bool $query Set true on a page that is used for querying return: \core_search\manager |
| is_global_search_enabled() X-Ref |
| Returns whether global search is enabled or not. return: bool |
| can_replace_course_search() X-Ref |
| Tests if global search is configured to be equivalent to the front page course search. return: bool |
| get_course_search_url() X-Ref |
| Returns the search URL for course search return: moodle_url |
| is_indexing_enabled() X-Ref |
| Returns whether indexing is enabled or not (you can enable indexing even when search is not enabled at the moment, so as to have it ready for students). return: bool True if indexing is enabled. |
| search_engine_instance(bool $query = false) X-Ref |
| Returns an instance of the search engine. param: bool $query If true, gets the query-only search engine (where configured) return: \core_search\engine |
| search_engine_instance_from_setting(string $setting) X-Ref |
| Loads a search engine based on the name given in settings, which can optionally include '-alternate' to indicate that an alternate version should be used. param: string $setting return: engine|null |
| get_engine() X-Ref |
| Returns the search engine. return: \core_search\engine |
| get_area_classname($areaid) X-Ref |
| Returns a search area class name. param: string $areaid return: string |
| get_search_area($areaid) X-Ref |
| Returns a new area search indexer instance. param: string $areaid return: \core_search\base|bool False if the area is not available. |
| get_search_areas_list($enabled = false) X-Ref |
| Return the list of available search areas. param: bool $enabled Return only the enabled ones. return: \core_search\base[] |
| get_search_area_category_by_name($name) X-Ref |
| Return search area category instance by category name. param: string $name Category name. If name is not valid will return default category. return: \core_search\area_category |
| get_search_area_categories() X-Ref |
| Return a list of existing search area categories. return: \core_search\area_category[] |
| get_core_search_area_categories() X-Ref |
| Get list of core search area categories. return: \core_search\area_category[] |
| get_additional_search_area_categories() X-Ref |
| Gets a list of additional search area categories. return: \core_search\area_category[] |
| is_valid_area_category($areacategory) X-Ref |
| Check if provided instance of area category is valid. param: mixed $areacategory Area category instance. Potentially could be anything. return: bool |
| clear_static() X-Ref |
| Clears all static caches. return: void |
| generate_areaid($componentname, $areaname) X-Ref |
| Generates an area id from the componentname and the area name. There should not be any naming conflict as the area name is the class name in component/classes/search/. param: string $componentname param: string $areaname return: void |
| extract_areaid_parts($areaid) X-Ref |
| Returns all areaid string components (component name and area name). param: string $areaid return: array Component name (Frankenstyle) and area name (search area class name) |
| parse_areaid($areaid) X-Ref |
| Parse a search area id and get plugin name and config name prefix from it. param: string $areaid Search area id. return: array Where the first element is a plugin name and the second is config names prefix. |
| get_areas_user_accesses($limitcourseids = false, $limitcontextids = false) X-Ref |
| Returns information about the areas which the user can access. The returned value is a stdClass object with the following fields: - everything (bool, true for admin only) - usercontexts (indexed by area identifier then context - separategroupscontexts (contexts within which group restrictions apply) - visiblegroupscontextsareas (overrides to the above when the same contexts also have 'visible groups' for certain search area ids - hopefully rare) - usergroups (groups which the current user belongs to) The areas can be limited by course id and context id. If specifying context ids, results are limited to the exact context ids specified and not their children (for example, giving the course context id would result in including search items with the course context id, and not anything from a context inside the course). For performance, you should also specify course id(s) when using context ids. param: array|false $limitcourseids An array of course ids to limit the search to. False for no limiting. param: array|false $limitcontextids An array of context ids to limit the search to. False for no limiting. return: \stdClass Object as described above |
| paged_search(\stdClass $formdata, $pagenum) X-Ref |
| Returns requested page of documents plus additional information for paging. This function does not perform any kind of security checking for access, the caller code should check that the current user have moodle/search:query capability. If a page is requested that is beyond the last result, the last valid page is returned in results, and actualpage indicates which page was returned. param: stdClass $formdata param: int $pagenum The 0 based page number. return: object An object with 3 properties: |
| search(\stdClass $formdata, $limit = 0) X-Ref |
| Returns documents from the engine based on the data provided. This function does not perform any kind of security checking, the caller code should check that the current user have moodle/search:query capability. It might return the results from the cache instead. Valid formdata options include: - q (query text) - courseids (optional list of course ids to restrict) - contextids (optional list of context ids to restrict) - context (Moodle context object for location user searched from) - order (optional ordering, one of the types supported by the search engine e.g. 'relevance') - userids (optional list of user ids to restrict) param: \stdClass $formdata Query input data (usually from search form) param: int $limit The maximum number of documents to return return: \core_search\document[] |
| search_top(\stdClass $formdata) X-Ref |
| Search for top ranked result. param: \stdClass $formdata search query data return: array|document[] |
| build_limitcourseids(\stdClass $formdata) X-Ref |
| Build a list of course ids to limit the search based on submitted form data. param: \stdClass $formdata Submitted search form data. return: array|bool |
| optimize_index() X-Ref |
| Merge separate index segments into one. |
| index($fullindex = false, $timelimit = 0, \progress_trace $progress = null) X-Ref |
| Index all documents. param: bool $fullindex Whether we should reindex everything or not. param: float $timelimit Time limit in seconds (0 = no time limit) param: \progress_trace|null $progress Optional class for tracking progress return: bool Whether there was any updated document or not. |
| index_context($context, $singleareaid = '', $timelimit = 0,\progress_trace $progress = null, $startfromarea = '', $startfromtime = 0) X-Ref |
| Indexes or reindexes a specific context of the system, e.g. one course. The function returns an object with field 'complete' (true or false). This function supports partial indexing via the time limit parameter. If the time limit expires, it will return values for $startfromarea and $startfromtime which can be passed next time to continue indexing. param: \context $context Context to restrict index. param: string $singleareaid If specified, indexes only the given area. param: float $timelimit Time limit in seconds (0 = no time limit) param: \progress_trace|null $progress Optional class for tracking progress param: string $startfromarea Area to start from param: int $startfromtime Timestamp to start from return: \stdClass Object indicating success |
| reset_config($areaid = false) X-Ref |
| Resets areas config. param: string $areaid return: void |
| delete_index($areaid = false) X-Ref |
| Deletes an area's documents or all areas documents. param: string $areaid The area id or false for all return: void |
| delete_index_by_id($id) X-Ref |
| Deletes index by id. param: int Solr Document string $id |
| get_areas_config($searchareas) X-Ref |
| Returns search areas configuration. param: \core_search\base[] $searchareas return: \stdClass[] $configsettings |
| trigger_search_results_viewed($other) X-Ref |
| Triggers search_results_viewed event Other data required: - q: The query string - page: The page number - title: Title filter - areaids: Search areas filter - courseids: Courses filter - timestart: Time start filter - timeend: Time end filter param: array $other Other info for the event. return: \core\event\search_results_viewed |
| is_search_area($classname) X-Ref |
| Checks whether a classname is of an actual search area. param: string $classname return: bool |
| request_index(\context $context, $areaid = '',$priority = self::INDEX_PRIORITY_NORMAL) X-Ref |
| Requests that a specific context is indexed by the scheduled task. The context will be added to a queue which is processed by the task. This is used after a restore to ensure that restored items are indexed, even though their modified time will be older than the latest indexed. It is also used by the 'Gradual reindex' admin feature from the search areas screen. param: \context $context Context to index within param: string $areaid Area to index, '' = all areas param: int $priority Priority (INDEX_PRIORITY_xx constant) |
| process_index_requests($timelimit = 0.0, \progress_trace $progress = null) X-Ref |
| Processes outstanding index requests. This will take the first item from the queue (taking account the indexing priority) and process it, continuing until an optional time limit is reached. If there are no index requests, the function will do nothing. param: float $timelimit Time limit (0 = none) param: \progress_trace|null $progress Optional progress indicator |
| get_index_requests_info() X-Ref |
| Gets information about the request queue, in the form of a plain object suitable for passing to a template for rendering. return: \stdClass Information about queued index requests |
| get_current_time() X-Ref |
| Gets current time for use in search system. Note: This should be replaced with generic core functionality once possible (see MDL-60644). return: float Current time in seconds (with decimals) |
| is_search_area_categories_enabled() X-Ref |
| Check if search area categories functionality is enabled. return: bool |
| should_hide_all_results_category() X-Ref |
| Check if all results category should be hidden. return: bool |
| get_default_area_category_name() X-Ref |
| Returns default search area category name. return: string |
| get_all_courses($limitcourseids) X-Ref |
| Get a list of all courses limited by ids if required. param: array|false $limitcourseids An array of course ids to limit the search to. False for no limiting. return: array |
| get_my_courses($allaccessible) X-Ref |
| Get a list of courses as user can access. param: bool $allaccessible Include courses user is not enrolled in, but can access. return: array |
| include_all_courses() X-Ref |
| Check if search all courses setting is enabled. return: bool |
| clean_up_non_existing_area($areaid) X-Ref |
| Cleans up non existing search area. 1. Remove all configs from {config_plugins} table. 2. Delete all related indexed documents. param: string $areaid Search area id. |
| context_deleted(\context $context) X-Ref |
| Informs the search system that a context has been deleted. This will clear the data from the search index, where the search engine supports that. This function does not usually throw an exception (so as not to get in the way of the context deletion finishing). This is called for all types of context deletion. param: \context $context Context object that has just been deleted |
| course_deleting_start(int $courseid) X-Ref |
| Informs the search system that a course is about to be deleted. This prevents it from sending hundreds of 'delete context' updates for all the individual contexts that are deleted. If you call this, you must call course_deleting_finish(). param: int $courseid Course id that is being deleted |
| course_deleting_finish(int $courseid) X-Ref |
| Informs the search engine that a course has now been deleted. This causes the search engine to actually delete the index for the whole course. param: int $courseid Course id that no longer exists |
