Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log |
<?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 blocks.** Note: Only blocks within courses are supported.** @package core_search* @copyright 2017 The Open University* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/namespace core_search;defined('MOODLE_INTERNAL') || die();/*** Search area base class for blocks.** Note: Only blocks within courses are supported.** @package core_search* @copyright 2017 The Open University* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/abstract class base_block extends base {/** @var string Cache name used for block instances */const CACHE_INSTANCES = 'base_block_instances';/*** 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_BLOCK];/*** Gets the block name only.** @return string Block name e.g. 'html'*/public function get_block_name() {// Remove 'block_' text.return substr($this->get_component_name(), 6);}/*** Returns restrictions on which block_instances rows to return. By default, excludes rows* that have empty configdata.** If no restriction is required, you could return ['', []].** @return array 2-element array of SQL restriction and params for it*/protected function get_indexing_restrictions() {global $DB;// This includes completely empty configdata, and also three other values that are// equivalent to empty:// - A serialized completely empty object.// - A serialized object with one field called '0' (string not int) set to boolean false// (this can happen after backup and restore, at least historically).// - A serialized null.$stupidobject = (object)[];$zero = '0';$stupidobject->{$zero} = false;return [$DB->sql_compare_text('bi.configdata') . " != ? AND " .$DB->sql_compare_text('bi.configdata') . " != ? AND " .$DB->sql_compare_text('bi.configdata') . " != ? AND " .$DB->sql_compare_text('bi.configdata') . " != ?",['', base64_encode(serialize((object)[])), base64_encode(serialize($stupidobject)),base64_encode(serialize(null))]];}/*** Gets recordset of all blocks of this type modified since given time within the given context.** See base class for detailed requirements. This implementation includes the key fields* from block_instances.** This can be overridden to do something totally different if the block's data is stored in* other tables.** If there are certain instances of the block which should not be included in the search index* then you can override get_indexing_restrictions; by default this excludes rows with empty* configdata.** @param int $modifiedfrom Return only records modified after this date* @param \context|null $context Context to find blocks within* @return false|\moodle_recordset|null*/public function get_document_recordset($modifiedfrom = 0, \context $context = null) {global $DB;// Get context restrictions.list ($contextjoin, $contextparams) = $this->get_context_restriction_sql($context, 'bi');// Get custom restrictions for block type.list ($restrictions, $restrictionparams) = $this->get_indexing_restrictions();if ($restrictions) {$restrictions = 'AND ' . $restrictions;}// Query for all entries in block_instances for this type of block, within the specified// context. The query is based on the one from get_recordset_by_timestamp and applies the// same restrictions.return $DB->get_recordset_sql("SELECT bi.id, bi.timemodified, bi.timecreated, bi.configdata,c.id AS courseid, x.id AS contextidFROM {block_instances} bi$contextjoinJOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ?JOIN {context} parent ON parent.id = bi.parentcontextidLEFT JOIN {course_modules} cm ON cm.id = parent.instanceid AND parent.contextlevel = ?JOIN {course} c ON c.id = cm.courseOR (c.id = parent.instanceid AND parent.contextlevel = ?)WHERE bi.timemodified >= ?AND bi.blockname = ?AND (parent.contextlevel = ? AND (" . $DB->sql_like('bi.pagetypepattern', '?') . "OR bi.pagetypepattern IN ('site-index', 'course-*', '*')))$restrictionsORDER BY bi.timemodified ASC",array_merge($contextparams, [CONTEXT_BLOCK, CONTEXT_MODULE, CONTEXT_COURSE,$modifiedfrom, $this->get_block_name(), CONTEXT_COURSE, 'course-view-%'],$restrictionparams));}public function get_doc_url(\core_search\document $doc) {// Load block instance and find cmid if there is one.$blockinstanceid = preg_replace('~^.*-~', '', $doc->get('id'));$instance = $this->get_block_instance($blockinstanceid);$courseid = $doc->get('courseid');$anchor = 'inst' . $blockinstanceid;// Check if the block is at course or module level.if ($instance->cmid) {// No module-level page types are supported at present so the search system won't return// them. But let's put some example code here to indicate how it could work.debugging('Unexpected module-level page type for block ' . $blockinstanceid . ': ' .$instance->pagetypepattern, DEBUG_DEVELOPER);$modinfo = get_fast_modinfo($courseid);$cm = $modinfo->get_cm($instance->cmid);return new \moodle_url($cm->url, null, $anchor);} else {// The block is at course level. Let's check the page type, although in practice we// currently only support the course main page.if ($instance->pagetypepattern === '*' || $instance->pagetypepattern === 'course-*' ||preg_match('~^course-view-(.*)$~', $instance->pagetypepattern)) {return new \moodle_url('/course/view.php', ['id' => $courseid], $anchor);} else if ($instance->pagetypepattern === 'site-index') {return new \moodle_url('/', ['redirect' => 0], $anchor);} else {debugging('Unexpected page type for block ' . $blockinstanceid . ': ' .$instance->pagetypepattern, DEBUG_DEVELOPER);return new \moodle_url('/course/view.php', ['id' => $courseid], $anchor);}}}public function get_context_url(\core_search\document $doc) {return $this->get_doc_url($doc);}/*** Checks access for a document in this search area.** If you override this function for a block, you should call this base class version first* as it will check that the block is still visible to users in a supported location.** @param int $id Document id* @return int manager:ACCESS_xx constant*/public function check_access($id) {$instance = $this->get_block_instance($id, IGNORE_MISSING);if (!$instance) {// This generally won't happen because if the block has been deleted then we won't have// included its context in the search area list, but just in case.return manager::ACCESS_DELETED;}// Check block has not been moved to an unsupported area since it was indexed. (At the// moment, only blocks within site and course context are supported, also only certain// page types.)if (!$instance->courseid ||!self::is_supported_page_type_at_course_context($instance->pagetypepattern)) {return manager::ACCESS_DELETED;}// Note we do not need to check if the block was hidden or if the user has access to the// context, because those checks are included in the list of search contexts user can access// that is calculated in manager.php every time they do a query.return manager::ACCESS_GRANTED;}/*** Checks if a page type is supported for blocks when at course (or also site) context. This* function should be consistent with the SQL in get_recordset_by_timestamp.** @param string $pagetype Page type* @return bool True if supported*/protected static function is_supported_page_type_at_course_context($pagetype) {if (in_array($pagetype, ['site-index', 'course-*', '*'])) {return true;}if (preg_match('~^course-view-~', $pagetype)) {return true;}return false;}/*** Gets a block instance with given id.** Returns the fields id, pagetypepattern, subpagepattern from block_instances and also the* cmid (if parent context is an activity module).** @param int $id ID of block instance* @param int $strictness MUST_EXIST or IGNORE_MISSING* @return false|mixed Block instance data (may be false if strictness is IGNORE_MISSING)*/protected function get_block_instance($id, $strictness = MUST_EXIST) {global $DB;$cache = \cache::make_from_params(\cache_store::MODE_REQUEST, 'core_search',self::CACHE_INSTANCES, [], ['simplekeys' => true]);$id = (int)$id;$instance = $cache->get($id);if (!$instance) {$instance = $DB->get_record_sql("SELECT bi.id, bi.pagetypepattern, bi.subpagepattern,c.id AS courseid, cm.id AS cmidFROM {block_instances} biJOIN {context} parent ON parent.id = bi.parentcontextidLEFT JOIN {course} c ON c.id = parent.instanceid AND parent.contextlevel = ?LEFT JOIN {course_modules} cm ON cm.id = parent.instanceid AND parent.contextlevel = ?WHERE bi.id = ?",[CONTEXT_COURSE, CONTEXT_MODULE, $id], $strictness);$cache->set($id, $instance);}return $instance;}/*** Clears static cache. This function can be removed (with calls to it in the test script* replaced with cache_helper::purge_all) if MDL-59427 is fixed.*/public static function clear_static() {\cache::make_from_params(\cache_store::MODE_REQUEST, 'core_search',self::CACHE_INSTANCES, [], ['simplekeys' => true])->purge();}/*** Helper function that gets SQL useful for restricting a search query given a passed-in* context.** The SQL returned will be one or more JOIN statements, surrounded by whitespace, which act* as restrictions on the query based on the rows in the block_instances table.** We assume the block instances have already been restricted by blockname.** Returns null if there can be no results for this block within this 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 $blocktable Alias of block_instances table* @param int $paramtype Type of SQL parameters to use (default question mark)* @return array Array with SQL and parameters* @throws \coding_exception If called with invalid params*/protected function get_context_restriction_sql(\context $context = null, $blocktable = 'bi',$paramtype = SQL_PARAMS_QM) {global $DB;if (!$context) {return ['', []];}switch ($paramtype) {case SQL_PARAMS_QM:$param1 = '?';$param2 = '?';$key1 = 0;$key2 = 1;break;case SQL_PARAMS_NAMED:$param1 = ':gcrs0';$param2 = ':gcrs1';$key1 = 'gcrs0';$key2 = 'gcrs1';break;default:throw new \coding_exception('Unexpected $paramtype: ' . $paramtype);}$params = [];switch ($context->contextlevel) {case CONTEXT_SYSTEM:$sql = '';break;case CONTEXT_COURSECAT:case CONTEXT_COURSE:case CONTEXT_MODULE:case CONTEXT_USER:// Find all blocks whose parent is within the specified context.$sql = " JOIN {context} gcrsx ON gcrsx.id = $blocktable.parentcontextidAND (gcrsx.id = $param1 OR " . $DB->sql_like('gcrsx.path', $param2) . ") ";$params[$key1] = $context->id;$params[$key2] = $context->path . '/%';break;case CONTEXT_BLOCK:// Find only the specified block of this type. Since we are generating JOINs// here, we do this by joining again to the block_instances table with the same ID.$sql = " JOIN {block_instances} gcrsbi ON gcrsbi.id = $blocktable.idAND gcrsbi.id = $param1 ";$params[$key1] = $context->instanceid;break;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 block_instances 'bi' and context 'x' already exist).* - An ORDER BY value which must use aggregate functions, by default 'MAX(bi.timemodified) 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(bi.timemodified) DESC'];}/*** Gets a list of all contexts to reindex when reindexing this search area.** For blocks, the default is to return all contexts for blocks of that type, that are on a* course page, 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 $selectcolumnsFROM {block_instances} biJOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ?JOIN {context} parent ON parent.id = bi.parentcontextid$extrajoinsWHERE bi.blockname = ? AND parent.contextlevel = ?GROUP BY $groupbycolumnsORDER BY $dborder", [CONTEXT_BLOCK, $this->get_block_name(), CONTEXT_COURSE]);return new \core\dml\recordset_walk($rs, function($rec) {$id = $rec->ctxid;\context_helper::preload_from_record($rec);return \context::instance_by_id($id);});}/*** 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('e/anchor');}/*** Returns a list of category names associated with the area.** @return array*/public function get_category_names() {return [manager::SEARCH_AREA_CATEGORY_COURSE_CONTENT];}}