You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
420 lines
17 KiB
420 lines
17 KiB
<?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 contextid
|
|
FROM {block_instances} bi
|
|
$contextjoin
|
|
JOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ?
|
|
JOIN {context} parent ON parent.id = bi.parentcontextid
|
|
LEFT JOIN {course_modules} cm ON cm.id = parent.instanceid AND parent.contextlevel = ?
|
|
JOIN {course} c ON c.id = cm.course
|
|
OR (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-*', '*')))
|
|
$restrictions
|
|
ORDER 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 cmid
|
|
FROM {block_instances} bi
|
|
JOIN {context} parent ON parent.id = bi.parentcontextid
|
|
LEFT 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.parentcontextid
|
|
AND (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.id
|
|
AND 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 $selectcolumns
|
|
FROM {block_instances} bi
|
|
JOIN {context} x ON x.instanceid = bi.id AND x.contextlevel = ?
|
|
JOIN {context} parent ON parent.id = bi.parentcontextid
|
|
$extrajoins
|
|
WHERE bi.blockname = ? AND parent.contextlevel = ?
|
|
GROUP BY $groupbycolumns
|
|
ORDER 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];
|
|
}
|
|
}
|
|
|