See Release Notes
Long Term Support Release
<?php // This file is part of Moodle - http://moodle.org/ // // Moodle is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // Moodle is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Moodle. If not, see <http://www.gnu.org/licenses/>. /** * Search area base class for areas working at module level. * * @package core_search * @copyright 2015 David Monllao {@link http://www.davidmonllao.com} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ namespace core_search; defined('MOODLE_INTERNAL') || die(); /** * Base implementation for search areas working at module level. * * Even if the search area works at multiple levels, if module is one of these levels * it should extend this class, as this class provides helper methods for module level search management. * * @package core_search * @copyright 2015 David Monllao {@link http://www.davidmonllao.com} * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ abstract class base_mod extends base { /** * The context levels the search area is working on. * * This can be overwriten by the search area if it works at multiple * levels. * * @var array */ protected static $levels = [CONTEXT_MODULE]; /** * Returns the module name. * * @return string */ protected function get_module_name() { return substr($this->componentname, 4); } /** * Gets the course module for the required instanceid + modulename. * * The returned data depends on the logged user, when calling this through * self::get_document the admin user is used so everything would be returned. * * No need more internal caching here, modinfo is already cached. * * @throws \dml_missing_record_exception * @param string $modulename The module name * @param int $instanceid Module instance id (depends on the module) * @param int $courseid Helps speeding up things * @return \cm_info */ protected function get_cm($modulename, $instanceid, $courseid) { $modinfo = get_fast_modinfo($courseid); // Hopefully not many, they are indexed by cmid. $instances = $modinfo->get_instances_of($modulename); foreach ($instances as $cminfo) { if ($cminfo->instance == $instanceid) { return $cminfo; } } // Nothing found. throw new \dml_missing_record_exception($modulename); } /** * Helper function that gets SQL useful for restricting a search query given a passed-in * context. * * The SQL returned will be zero or more JOIN statements, surrounded by whitespace, which act * as restrictions on the query based on the rows in a module table. * * You can pass in a null or system context, which will both return an empty string and no * params. * * Returns an array with two nulls if there can be no results for the activity within this * context (e.g. it is a block context). * * If named parameters are used, these will be named gcrs0, gcrs1, etc. The table aliases used * in SQL also all begin with gcrs, to avoid conflicts. * * @param \context|null $context Context to restrict the query * @param string $modname Name of module e.g. 'forum' * @param string $modtable Alias of table containing module id * @param int $paramtype Type of SQL parameters to use (default question mark) * @return array Array with SQL and parameters; both null if no need to query * @throws \coding_exception If called with invalid params */< protected function get_context_restriction_sql(\context $context = null, $modname, $modtable,> protected function get_context_restriction_sql(?\context $context, $modname, $modtable,$paramtype = SQL_PARAMS_QM) { global $DB; if (!$context) { return ['', []]; } switch ($paramtype) { case SQL_PARAMS_QM: $param1 = '?'; $param2 = '?'; $param3 = '?'; $key1 = 0; $key2 = 1; $key3 = 2; break; case SQL_PARAMS_NAMED: $param1 = ':gcrs0'; $param2 = ':gcrs1'; $param3 = ':gcrs2'; $key1 = 'gcrs0'; $key2 = 'gcrs1'; $key3 = 'gcrs2'; break; default: throw new \coding_exception('Unexpected $paramtype: ' . $paramtype); } $params = []; switch ($context->contextlevel) { case CONTEXT_SYSTEM: $sql = ''; break; case CONTEXT_COURSECAT: // Find all activities of this type within the specified category or any // sub-category. $pathmatch = $DB->sql_like('gcrscc2.path', $DB->sql_concat('gcrscc1.path', $param3)); $sql = " JOIN {course_modules} gcrscm ON gcrscm.instance = $modtable.id AND gcrscm.module = (SELECT id FROM {modules} WHERE name = $param1) JOIN {course} gcrsc ON gcrsc.id = gcrscm.course JOIN {course_categories} gcrscc1 ON gcrscc1.id = $param2 JOIN {course_categories} gcrscc2 ON gcrscc2.id = gcrsc.category AND (gcrscc2.id = gcrscc1.id OR $pathmatch) "; $params[$key1] = $modname; $params[$key2] = $context->instanceid; // Note: This param is a bit annoying as it obviously never changes, but sql_like // throws a debug warning if you pass it anything with quotes in, so it has to be // a bound parameter. $params[$key3] = '/%'; break; case CONTEXT_COURSE: // Find all activities of this type within the course. $sql = " JOIN {course_modules} gcrscm ON gcrscm.instance = $modtable.id AND gcrscm.course = $param1 AND gcrscm.module = (SELECT id FROM {modules} WHERE name = $param2) "; $params[$key1] = $context->instanceid; $params[$key2] = $modname; break; case CONTEXT_MODULE: // Find only the specified activity of this type. $sql = " JOIN {course_modules} gcrscm ON gcrscm.instance = $modtable.id AND gcrscm.id = $param1 AND gcrscm.module = (SELECT id FROM {modules} WHERE name = $param2) "; $params[$key1] = $context->instanceid; $params[$key2] = $modname; break; case CONTEXT_BLOCK: case CONTEXT_USER: // These contexts cannot contain any activities, so return null. return [null, null]; default: throw new \coding_exception('Unexpected contextlevel: ' . $context->contextlevel); } return [$sql, $params]; } /** * This can be used in subclasses to change ordering within the get_contexts_to_reindex * function. * * It returns 2 values: * - Extra SQL joins (tables course_modules 'cm' and context 'x' already exist). * - An ORDER BY value which must use aggregate functions, by default 'MAX(cm.added) DESC'. * * Note the query already includes a GROUP BY on the context fields, so if your joins result * in multiple rows, you can use aggregate functions in the ORDER BY. See forum for an example. * * @return string[] Array with 2 elements; extra joins for the query, and ORDER BY value */ protected function get_contexts_to_reindex_extra_sql() { return ['', 'MAX(cm.added) DESC']; } /** * Gets a list of all contexts to reindex when reindexing this search area. * * For modules, the default is to return all contexts for modules of that type, in order of * time added (most recent first). * * @return \Iterator Iterator of contexts to reindex * @throws \moodle_exception If any DB error */ public function get_contexts_to_reindex() { global $DB; list ($extrajoins, $dborder) = $this->get_contexts_to_reindex_extra_sql(); $contexts = []; $selectcolumns = \context_helper::get_preload_record_columns_sql('x'); $groupbycolumns = ''; foreach (\context_helper::get_preload_record_columns('x') as $column => $thing) { if ($groupbycolumns !== '') { $groupbycolumns .= ','; } $groupbycolumns .= $column; } $rs = $DB->get_recordset_sql(" SELECT $selectcolumns FROM {course_modules} cm JOIN {context} x ON x.instanceid = cm.id AND x.contextlevel = ? $extrajoins WHERE cm.module = (SELECT id FROM {modules} WHERE name = ?) GROUP BY $groupbycolumns ORDER BY $dborder", [CONTEXT_MODULE, $this->get_module_name()]); return new \core\dml\recordset_walk($rs, function($rec) { $id = $rec->ctxid; \context_helper::preload_from_record($rec); return \context::instance_by_id($id); }); } /** * Indicates whether this search area may restrict access by group. * * This should return true if the search area (sometimes) sets the 'groupid' schema field, and * false if it never sets that field. * * (If this function returns false, but the field is set, then results may be restricted * unintentionally.) * * If this returns true, the search engine will automatically apply group restrictions in some * cases (by default, where a module is configured to use separate groups). See function * restrict_cm_access_by_group(). * * @return bool */ public function supports_group_restriction() { return false; } /** * Checks whether the content of this search area should be restricted by group for a * specific module. Called at query time. * * The default behaviour simply checks if the effective group mode is SEPARATEGROUPS, which * is probably correct for most cases. * * If restricted by group, the search query will (where supported by the engine) filter out * results for groups the user does not belong to, unless the user has 'access all groups' * for the activity. This affects only documents which set the 'groupid' field; results with no * groupid will not be restricted. * * Even if you return true to this function, you may still need to do group access checks in * check_access, because the search engine may not support group restrictions. * * @param \cm_info $cm * @return bool True to restrict by group */ public function restrict_cm_access_by_group(\cm_info $cm) { return $cm->effectivegroupmode == SEPARATEGROUPS; } /** * Returns an icon instance for the document. * * @param \core_search\document $doc * @return \core_search\document_icon */ public function get_doc_icon(document $doc) : document_icon {< return new document_icon('icon', $this->get_module_name());> return new document_icon('monologo', $this->get_module_name());} /** * Returns a list of category names associated with the area. * * @return array */ public function get_category_names() { return [manager::SEARCH_AREA_CATEGORY_COURSE_CONTENT]; } }