mirror of
https://github.com/moodle/moodle.git
synced 2025-08-11 03:46:42 +02:00
533 lines
18 KiB
PHP
533 lines
18 KiB
PHP
<?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/>.
|
|
|
|
/**
|
|
* Entry query builder.
|
|
*
|
|
* @package mod_glossary
|
|
* @copyright 2015 Frédéric Massart - FMCorz.net
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Entry query builder class.
|
|
*
|
|
* The purpose of this class is to avoid duplicating SQL statements to fetch entries
|
|
* which are very similar with each other. This builder is not meant to be smart, it
|
|
* will not out rule any previously set condition, or join, etc...
|
|
*
|
|
* You should be using this builder just like you would be creating your SQL query. Only
|
|
* some methods are shorthands to avoid logic duplication and common mistakes.
|
|
*
|
|
* @package mod_glossary
|
|
* @copyright 2015 Frédéric Massart - FMCorz.net
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class mod_glossary_entry_query_builder {
|
|
|
|
/** Alias for table glossary_alias. */
|
|
const ALIAS_ALIAS = 'ga';
|
|
/** Alias for table glossary_categories. */
|
|
const ALIAS_CATEGORIES = 'gc';
|
|
/** Alias for table glossary_entries_categories. */
|
|
const ALIAS_ENTRIES_CATEGORIES = 'gec';
|
|
/** Alias for table glossary_entries. */
|
|
const ALIAS_ENTRIES = 'ge';
|
|
/** Alias for table user. */
|
|
const ALIAS_USER = 'u';
|
|
|
|
/** Include none of the entries to approve. */
|
|
const NON_APPROVED_NONE = 'na_none';
|
|
/** Including all the entries. */
|
|
const NON_APPROVED_ALL = 'na_all';
|
|
/** Including only the entries to be approved. */
|
|
const NON_APPROVED_ONLY = 'na_only';
|
|
/** Including my entries to be approved. */
|
|
const NON_APPROVED_SELF = 'na_self';
|
|
|
|
/** @var array Raw SQL statements representing the fields to select. */
|
|
protected $fields = array();
|
|
/** @var array Raw SQL statements representing the JOINs to make. */
|
|
protected $joins = array();
|
|
/** @var string Raw SQL statement representing the FROM clause. */
|
|
protected $from;
|
|
/** @var object The glossary we are fetching from. */
|
|
protected $glossary;
|
|
/** @var int The number of records to fetch from. */
|
|
protected $limitfrom = 0;
|
|
/** @var int The number of records to fetch. */
|
|
protected $limitnum = 0;
|
|
/** @var array List of SQL parameters. */
|
|
protected $params = array();
|
|
/** @var array Raw SQL statements representing the ORDER clause. */
|
|
protected $order = array();
|
|
/** @var array Raw SQL statements representing the WHERE clause. */
|
|
protected $where = array();
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param object $glossary The glossary.
|
|
*/
|
|
public function __construct($glossary = null) {
|
|
$this->from = sprintf('FROM {glossary_entries} %s', self::ALIAS_ENTRIES);
|
|
if (!empty($glossary)) {
|
|
$this->glossary = $glossary;
|
|
$this->where[] = sprintf('(%s.glossaryid = :gid OR %s.sourceglossaryid = :gid2)', self::ALIAS_ENTRIES, self::ALIAS_ENTRIES);
|
|
$this->params['gid'] = $glossary->id;
|
|
$this->params['gid2'] = $glossary->id;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a field to select.
|
|
*
|
|
* @param string $field The field, or *.
|
|
* @param string $table The table name, without the prefix 'glossary_'.
|
|
* @param string $alias An alias for the field.
|
|
*/
|
|
public function add_field($field, $table, $alias = null) {
|
|
$field = self::resolve_field($field, $table);
|
|
if (!empty($alias)) {
|
|
$field .= ' AS ' . $alias;
|
|
}
|
|
$this->fields[] = $field;
|
|
}
|
|
|
|
/**
|
|
* Adds the user fields.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function add_user_fields() {
|
|
$this->fields[] = user_picture::fields('u', null, 'userdataid', 'userdata');
|
|
}
|
|
|
|
/**
|
|
* Internal method to build the query.
|
|
*
|
|
* @param boolean $count Query to count?
|
|
* @return string The SQL statement.
|
|
*/
|
|
protected function build_query($count = false) {
|
|
$sql = 'SELECT ';
|
|
|
|
if ($count) {
|
|
$sql .= 'COUNT(\'x\') ';
|
|
} else {
|
|
$sql .= implode(', ', $this->fields) . ' ';
|
|
}
|
|
|
|
$sql .= $this->from . ' ';
|
|
$sql .= implode(' ', $this->joins) . ' ';
|
|
|
|
if (!empty($this->where)) {
|
|
$sql .= 'WHERE (' . implode(') AND (', $this->where) . ') ';
|
|
}
|
|
|
|
if (!$count && !empty($this->order)) {
|
|
$sql .= 'ORDER BY ' . implode(', ', $this->order);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Count the records.
|
|
*
|
|
* @return int
|
|
*/
|
|
public function count_records() {
|
|
global $DB;
|
|
return $DB->count_records_sql($this->build_query(true), $this->params);
|
|
}
|
|
|
|
/**
|
|
* Distinct a field.
|
|
*
|
|
* @param string $field The field.
|
|
* @param string $table The table name, without the prefix 'glossary_'.
|
|
*/
|
|
public function distinct($field, $table) {
|
|
$field = self::resolve_field($field, $table);
|
|
array_unshift($this->fields, 'DISTINCT(' . $field . ')');
|
|
}
|
|
|
|
/**
|
|
* Filter a field using a letter.
|
|
*
|
|
* @param string $letter The letter.
|
|
* @param string $finalfield The SQL statement representing the field.
|
|
*/
|
|
protected function filter_by_letter($letter, $finalfield) {
|
|
global $DB;
|
|
|
|
$letter = core_text::strtoupper($letter);
|
|
$len = core_text::strlen($letter);
|
|
$sql = $DB->sql_substr(sprintf('upper(%s)', $finalfield), 1, $len);
|
|
|
|
$this->where[] = "$sql = :letter";
|
|
$this->params['letter'] = $letter;
|
|
}
|
|
|
|
/**
|
|
* Filter a field by special characters.
|
|
*
|
|
* @param string $finalfield The SQL statement representing the field.
|
|
*/
|
|
protected function filter_by_non_letter($finalfield) {
|
|
global $DB;
|
|
|
|
$alphabet = explode(',', get_string('alphabet', 'langconfig'));
|
|
list($nia, $aparams) = $DB->get_in_or_equal($alphabet, SQL_PARAMS_NAMED, 'nonletter', false);
|
|
|
|
$sql = $DB->sql_substr(sprintf('upper(%s)', $finalfield), 1, 1);
|
|
|
|
$this->where[] = "$sql $nia";
|
|
$this->params = array_merge($this->params, $aparams);
|
|
}
|
|
|
|
/**
|
|
* Filter the author by letter.
|
|
*
|
|
* @param string $letter The letter.
|
|
* @param boolean $firstnamefirst Whether or not the firstname is first in the author's name.
|
|
*/
|
|
public function filter_by_author_letter($letter, $firstnamefirst = false) {
|
|
$field = self::get_fullname_field($firstnamefirst);
|
|
$this->filter_by_letter($letter, $field);
|
|
}
|
|
|
|
/**
|
|
* Filter the author by special characters.
|
|
*
|
|
* @param boolean $firstnamefirst Whether or not the firstname is first in the author's name.
|
|
*/
|
|
public function filter_by_author_non_letter($firstnamefirst = false) {
|
|
$field = self::get_fullname_field($firstnamefirst);
|
|
$this->filter_by_non_letter($field);
|
|
}
|
|
|
|
/**
|
|
* Filter the concept by letter.
|
|
*
|
|
* @param string $letter The letter.
|
|
*/
|
|
public function filter_by_concept_letter($letter) {
|
|
$this->filter_by_letter($letter, self::resolve_field('concept', 'entries'));
|
|
}
|
|
|
|
/**
|
|
* Filter the concept by special characters.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function filter_by_concept_non_letter() {
|
|
$this->filter_by_non_letter(self::resolve_field('concept', 'entries'));
|
|
}
|
|
|
|
/**
|
|
* Filter non approved entries.
|
|
*
|
|
* @param string $constant One of the NON_APPROVED_* constants.
|
|
* @param int $userid The user ID when relevant, otherwise current user.
|
|
*/
|
|
public function filter_by_non_approved($constant, $userid = null) {
|
|
global $USER;
|
|
if (!$userid) {
|
|
$userid = $USER->id;
|
|
}
|
|
|
|
if ($constant === self::NON_APPROVED_ALL) {
|
|
// Nothing to do.
|
|
|
|
} else if ($constant === self::NON_APPROVED_SELF) {
|
|
$this->where[] = sprintf('%s != 0 OR %s = :toapproveuserid',
|
|
self::resolve_field('approved', 'entries'), self::resolve_field('userid', 'entries'));
|
|
$this->params['toapproveuserid'] = $USER->id;
|
|
|
|
} else if ($constant === self::NON_APPROVED_NONE) {
|
|
$this->where[] = sprintf('%s != 0', self::resolve_field('approved', 'entries'));
|
|
|
|
} else if ($constant === self::NON_APPROVED_ONLY) {
|
|
$this->where[] = sprintf('%s = 0', self::resolve_field('approved', 'entries'));
|
|
|
|
} else {
|
|
throw new coding_exception('Invalid constant');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Filter by search terms.
|
|
*
|
|
* Note that this does not handle invalid or too short terms. This requires the alias
|
|
* table to be joined in the query. See {@link self::join_alias()}.
|
|
*
|
|
* @param array $terms Array of terms.
|
|
* @param boolean $fullsearch Whether or not full search should be enabled.
|
|
*/
|
|
public function filter_by_search_terms(array $terms, $fullsearch = true) {
|
|
global $DB;
|
|
static $i = 0;
|
|
|
|
if ($DB->sql_regex_supported()) {
|
|
$regexp = $DB->sql_regex(true);
|
|
$notregexp = $DB->sql_regex(false);
|
|
}
|
|
|
|
$params = array();
|
|
$conceptfield = self::resolve_field('concept', 'entries');
|
|
$aliasfield = self::resolve_field('alias', 'alias');
|
|
$definitionfield = self::resolve_field('definition', 'entries');
|
|
$conditions = array();
|
|
|
|
foreach ($terms as $searchterm) {
|
|
$i++;
|
|
|
|
$not = false; // Initially we aren't going to perform NOT LIKE searches, only MSSQL and Oracle
|
|
// will use it to simulate the "-" operator with LIKE clause.
|
|
|
|
if (empty($fullsearch)) {
|
|
// With fullsearch disabled, look only within concepts and aliases.
|
|
$concat = $DB->sql_concat($conceptfield, "' '", "COALESCE($aliasfield, :emptychar{$i})");
|
|
} else {
|
|
// With fullsearch enabled, look also within definitions.
|
|
$concat = $DB->sql_concat($conceptfield, "' '", $definitionfield, "' '", "COALESCE($aliasfield, :emptychar{$i})");
|
|
}
|
|
$params['emptychar' . $i] = '';
|
|
|
|
// Under Oracle and MSSQL, trim the + and - operators and perform simpler LIKE (or NOT LIKE) queries.
|
|
if (!$DB->sql_regex_supported()) {
|
|
if (substr($searchterm, 0, 1) === '-') {
|
|
$not = true;
|
|
}
|
|
$searchterm = trim($searchterm, '+-');
|
|
}
|
|
|
|
if (substr($searchterm, 0, 1) === '+') {
|
|
$searchterm = trim($searchterm, '+-');
|
|
$conditions[] = "$concat $regexp :searchterm{$i}";
|
|
$params['searchterm' . $i] = '(^|[^a-zA-Z0-9])' . preg_quote($searchterm, '|') . '([^a-zA-Z0-9]|$)';
|
|
|
|
} else if (substr($searchterm, 0, 1) === "-") {
|
|
$searchterm = trim($searchterm, '+-');
|
|
$conditions[] = "$concat $notregexp :searchterm{$i}";
|
|
$params['searchterm' . $i] = '(^|[^a-zA-Z0-9])' . preg_quote($searchterm, '|') . '([^a-zA-Z0-9]|$)';
|
|
|
|
} else {
|
|
$conditions[] = $DB->sql_like($concat, ":searchterm{$i}", false, true, $not);
|
|
$params['searchterm' . $i] = '%' . $DB->sql_like_escape($searchterm) . '%';
|
|
}
|
|
}
|
|
|
|
$this->where[] = implode(' AND ', $conditions);
|
|
$this->params = array_merge($this->params, $params);
|
|
}
|
|
|
|
/**
|
|
* Convenience method to get get the SQL statement for the full name.
|
|
*
|
|
* @param boolean $firstnamefirst Whether or not the firstname is first in the author's name.
|
|
* @return string The SQL statement.
|
|
*/
|
|
public static function get_fullname_field($firstnamefirst = false) {
|
|
global $DB;
|
|
if ($firstnamefirst) {
|
|
return $DB->sql_fullname(self::resolve_field('firstname', 'user'), self::resolve_field('lastname', 'user'));
|
|
}
|
|
return $DB->sql_fullname(self::resolve_field('lastname', 'user'), self::resolve_field('firstname', 'user'));
|
|
}
|
|
|
|
/**
|
|
* Get the records.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_records() {
|
|
global $DB;
|
|
return $DB->get_records_sql($this->build_query(), $this->params, $this->limitfrom, $this->limitnum);
|
|
}
|
|
|
|
/**
|
|
* Get the recordset.
|
|
*
|
|
* @return moodle_recordset
|
|
*/
|
|
public function get_recordset() {
|
|
global $DB;
|
|
return $DB->get_recordset_sql($this->build_query(), $this->params, $this->limitfrom, $this->limitnum);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a user object from a record.
|
|
*
|
|
* This comes handy when {@link self::add_user_fields} was used.
|
|
*
|
|
* @param stdClass $record The record.
|
|
* @return stdClass A user object.
|
|
*/
|
|
public static function get_user_from_record($record) {
|
|
return user_picture::unalias($record, null, 'userdataid', 'userdata');
|
|
}
|
|
|
|
/**
|
|
* Join the alias table.
|
|
*
|
|
* Note that this may cause the same entry to be returned more than once. You might want
|
|
* to add a distinct on the entry id. See {@link self::distinct()}.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function join_alias() {
|
|
$this->joins[] = sprintf('LEFT JOIN {glossary_alias} %s ON %s = %s',
|
|
self::ALIAS_ALIAS, self::resolve_field('id', 'entries'), self::resolve_field('entryid', 'alias'));
|
|
}
|
|
|
|
/**
|
|
* Join on the category tables.
|
|
*
|
|
* Depending on the category passed the joins will be different. This is due to the display
|
|
* logic that assumes that when displaying all categories the non categorised entries should
|
|
* not be returned, etc...
|
|
*
|
|
* @param int $categoryid The category ID, or GLOSSARY_SHOW_* constant.
|
|
*/
|
|
public function join_category($categoryid) {
|
|
|
|
if ($categoryid === GLOSSARY_SHOW_ALL_CATEGORIES) {
|
|
$this->joins[] = sprintf('JOIN {glossary_entries_categories} %s ON %s = %s',
|
|
self::ALIAS_ENTRIES_CATEGORIES, self::resolve_field('id', 'entries'),
|
|
self::resolve_field('entryid', 'entries_categories'));
|
|
|
|
$this->joins[] = sprintf('JOIN {glossary_categories} %s ON %s = %s',
|
|
self::ALIAS_CATEGORIES, self::resolve_field('id', 'categories'),
|
|
self::resolve_field('categoryid', 'entries_categories'));
|
|
|
|
} else if ($categoryid === GLOSSARY_SHOW_NOT_CATEGORISED) {
|
|
$this->joins[] = sprintf('LEFT JOIN {glossary_entries_categories} %s ON %s = %s',
|
|
self::ALIAS_ENTRIES_CATEGORIES, self::resolve_field('id', 'entries'),
|
|
self::resolve_field('entryid', 'entries_categories'));
|
|
|
|
} else {
|
|
$this->joins[] = sprintf('JOIN {glossary_entries_categories} %s ON %s = %s AND %s = :joincategoryid',
|
|
self::ALIAS_ENTRIES_CATEGORIES, self::resolve_field('id', 'entries'),
|
|
self::resolve_field('entryid', 'entries_categories'),
|
|
self::resolve_field('categoryid', 'entries_categories'));
|
|
$this->params['joincategoryid'] = $categoryid;
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Join the user table.
|
|
*
|
|
* @param boolean $strict When strict uses a JOIN rather than a LEFT JOIN.
|
|
*/
|
|
public function join_user($strict = false) {
|
|
$join = $strict ? 'JOIN' : 'LEFT JOIN';
|
|
$this->joins[] = sprintf("$join {user} %s ON %s = %s",
|
|
self::ALIAS_USER, self::resolve_field('id', 'user'), self::resolve_field('userid', 'entries'));
|
|
}
|
|
|
|
/**
|
|
* Limit the number of records to fetch.
|
|
* @param int $from Fetch from.
|
|
* @param int $num Number to fetch.
|
|
*/
|
|
public function limit($from, $num) {
|
|
$this->limitfrom = $from;
|
|
$this->limitnum = $num;
|
|
}
|
|
|
|
/**
|
|
* Normalise a direction.
|
|
*
|
|
* This ensures that the value is either ASC or DESC.
|
|
*
|
|
* @param string $direction The desired direction.
|
|
* @return string ASC or DESC.
|
|
*/
|
|
protected function normalize_direction($direction) {
|
|
$direction = core_text::strtoupper($direction);
|
|
if ($direction == 'DESC') {
|
|
return 'DESC';
|
|
}
|
|
return 'ASC';
|
|
}
|
|
|
|
/**
|
|
* Order by a field.
|
|
*
|
|
* @param string $field The field, or *.
|
|
* @param string $table The table name, without the prefix 'glossary_'.
|
|
* @param string $direction ASC, or DESC.
|
|
*/
|
|
public function order_by($field, $table, $direction = '') {
|
|
$direction = self::normalize_direction($direction);
|
|
$this->order[] = self::resolve_field($field, $table) . ' ' . $direction;
|
|
}
|
|
|
|
/**
|
|
* Order by author name.
|
|
*
|
|
* @param boolean $firstnamefirst Whether or not the firstname is first in the author's name.
|
|
* @param string $direction [description]
|
|
* @param string $direction ASC, or DESC.
|
|
*/
|
|
public function order_by_author($firstnamefirst = false, $direction = '') {
|
|
$field = self::get_fullname_field($firstnamefirst);
|
|
$direction = self::normalize_direction($direction);
|
|
$this->order[] = $field . ' ' . $direction;
|
|
}
|
|
|
|
/**
|
|
* Convenience method to transform a field into SQL statement.
|
|
*
|
|
* @param string $field The field, or *.
|
|
* @param string $table The table name, without the prefix 'glossary_'.
|
|
* @return string SQL statement.
|
|
*/
|
|
protected static function resolve_field($field, $table) {
|
|
$prefix = constant(__CLASS__ . '::ALIAS_' . core_text::strtoupper($table));
|
|
return sprintf('%s.%s', $prefix, $field);
|
|
}
|
|
|
|
/**
|
|
* Simple where conditions.
|
|
*
|
|
* @param string $field The field, or *.
|
|
* @param string $table The table name, without the prefix 'glossary_'.
|
|
* @param mixed $value The value to be equal to.
|
|
*/
|
|
public function where($field, $table, $value) {
|
|
static $i = 0;
|
|
$sql = self::resolve_field($field, $table) . ' ';
|
|
|
|
if ($value === null) {
|
|
$sql .= 'IS NULL';
|
|
|
|
} else {
|
|
$param = 'where' . $i++;
|
|
$sql .= " = :$param";
|
|
$this->params[$param] = $value;
|
|
}
|
|
|
|
$this->where[] = $sql;
|
|
}
|
|
|
|
}
|