mirror of
https://github.com/moodle/moodle.git
synced 2025-01-17 21:49:15 +01:00
442 lines
16 KiB
PHP
442 lines
16 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/>.
|
|
|
|
/**
|
|
* Functions used to show question editing interface
|
|
*
|
|
* @package moodlecore
|
|
* @subpackage questionbank
|
|
* @copyright 1999 onwards Martin Dougiamas and others {@link http://moodle.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
use core\output\datafilter;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once($CFG->libdir . '/questionlib.php');
|
|
|
|
define('DEFAULT_QUESTIONS_PER_PAGE', 100);
|
|
define('MAXIMUM_QUESTIONS_PER_PAGE', 4000);
|
|
|
|
function get_module_from_cmid($cmid) {
|
|
global $CFG, $DB;
|
|
if (!$cmrec = $DB->get_record_sql("SELECT cm.*, md.name as modname
|
|
FROM {course_modules} cm,
|
|
{modules} md
|
|
WHERE cm.id = ? AND
|
|
md.id = cm.module", array($cmid))){
|
|
throw new \moodle_exception('invalidcoursemodule');
|
|
} elseif (!$modrec =$DB->get_record($cmrec->modname, array('id' => $cmrec->instance))) {
|
|
throw new \moodle_exception('invalidcoursemodule');
|
|
}
|
|
$modrec->instance = $modrec->id;
|
|
$modrec->cmid = $cmrec->id;
|
|
$cmrec->name = $modrec->name;
|
|
|
|
return array($modrec, $cmrec);
|
|
}
|
|
|
|
/**
|
|
* Function to read all questions for category into big array
|
|
*
|
|
* @param object $category category number
|
|
* @param bool $noparent if true only questions with NO parent will be selected
|
|
* @param bool $recurse include subdirectories
|
|
* @param bool $export set true if this is called by questionbank export
|
|
* @param bool $latestversion if only the latest versions needed
|
|
* @return array
|
|
*/
|
|
function get_questions_category(object $category, bool $noparent, bool $recurse = true, bool $export = true,
|
|
bool $latestversion = false): array {
|
|
global $DB;
|
|
|
|
// Build sql bit for $noparent.
|
|
$npsql = '';
|
|
if ($noparent) {
|
|
$npsql = " and q.parent='0' ";
|
|
}
|
|
|
|
// Get list of categories.
|
|
if ($recurse) {
|
|
$categorylist = question_categorylist($category->id);
|
|
} else {
|
|
$categorylist = [$category->id];
|
|
}
|
|
|
|
// Get the list of questions for the category.
|
|
list($usql, $params) = $DB->get_in_or_equal($categorylist);
|
|
|
|
// Get the latest version of a question.
|
|
$version = '';
|
|
if ($latestversion) {
|
|
$version = 'AND (qv.version = (SELECT MAX(v.version)
|
|
FROM {question_versions} v
|
|
JOIN {question_bank_entries} be
|
|
ON be.id = v.questionbankentryid
|
|
WHERE be.id = qbe.id) OR qv.version is null)';
|
|
}
|
|
$questions = $DB->get_records_sql("SELECT q.*, qv.status, qc.id AS category
|
|
FROM {question} q
|
|
JOIN {question_versions} qv ON qv.questionid = q.id
|
|
JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid
|
|
JOIN {question_categories} qc ON qc.id = qbe.questioncategoryid
|
|
WHERE qc.id {$usql} {$npsql} {$version}
|
|
ORDER BY qc.id, q.qtype, q.name", $params);
|
|
|
|
// Iterate through questions, getting stuff we need.
|
|
$qresults = [];
|
|
foreach($questions as $key => $question) {
|
|
$question->export_process = $export;
|
|
$qtype = question_bank::get_qtype($question->qtype, false);
|
|
if ($export && $qtype->name() === 'missingtype') {
|
|
// Unrecognised question type. Skip this question when exporting.
|
|
continue;
|
|
}
|
|
$qtype->get_question_options($question);
|
|
$qresults[] = $question;
|
|
}
|
|
|
|
return $qresults;
|
|
}
|
|
|
|
/**
|
|
* Common setup for all pages for editing questions.
|
|
* @param string $baseurl the name of the script calling this funciton. For examle 'qusetion/edit.php'.
|
|
* @param string $edittab code for this edit tab
|
|
* @param bool $requirecmid require cmid? default false
|
|
* @param bool $unused no longer used, do no pass
|
|
* @return array $thispageurl, $contexts, $cmid, $cm, $module, $pagevars
|
|
*/
|
|
function question_edit_setup($edittab, $baseurl, $requirecmid = false, $unused = null) {
|
|
global $PAGE;
|
|
|
|
if ($unused !== null) {
|
|
debugging('Deprecated argument passed to question_edit_setup()', DEBUG_DEVELOPER);
|
|
}
|
|
|
|
$params = [];
|
|
|
|
if ($requirecmid) {
|
|
$params['cmid'] = required_param('cmid', PARAM_INT);
|
|
} else {
|
|
$params['cmid'] = optional_param('cmid', null, PARAM_INT);
|
|
}
|
|
|
|
if (!$params['cmid']) {
|
|
$params['courseid'] = required_param('courseid', PARAM_INT);
|
|
}
|
|
|
|
$params['qpage'] = optional_param('qpage', null, PARAM_INT);
|
|
|
|
// Pass 'cat' from page to page and when 'category' comes from a drop down menu
|
|
// then we also reset the qpage so we go to page 1 of
|
|
// a new cat.
|
|
$params['cat'] = optional_param('cat', null, PARAM_SEQUENCE); // If empty will be set up later.
|
|
$params['category'] = optional_param('category', null, PARAM_SEQUENCE);
|
|
$params['qperpage'] = optional_param('qperpage', null, PARAM_INT);
|
|
|
|
// Display options.
|
|
$params['filter'] = optional_param('filter', null, PARAM_RAW);
|
|
|
|
// Category list page.
|
|
$params['cpage'] = optional_param('cpage', null, PARAM_INT);
|
|
|
|
// Sort data.
|
|
$params['sortdata'] = optional_param_array('sortdata', [], PARAM_INT);
|
|
|
|
$PAGE->set_pagelayout('admin');
|
|
|
|
return question_build_edit_resources($edittab, $baseurl, $params);
|
|
}
|
|
|
|
/**
|
|
* Common function for building the generic resources required by the
|
|
* editing questions pages.
|
|
*
|
|
* Either a cmid or a course id must be provided as keys in $params or
|
|
* an exception will be thrown. All other params are optional and will have
|
|
* sane default applied if not provided.
|
|
*
|
|
* The acceptable keys for $params are:
|
|
* [
|
|
* 'cmid' => PARAM_INT,
|
|
* 'courseid' => PARAM_INT,
|
|
* 'qpage' => PARAM_INT,
|
|
* 'cat' => PARAM_SEQUENCE,
|
|
* 'category' => PARAM_SEQUENCE,
|
|
* 'qperpage' => PARAM_INT,
|
|
* 'cpage' => PARAM_INT,
|
|
* 'recurse' => PARAM_BOOL,
|
|
* 'showhidden' => PARAM_BOOL,
|
|
* 'qbshowtext' => PARAM_INT,
|
|
* 'qtagids' => [PARAM_INT], (array of integers)
|
|
* 'qbs1' => PARAM_TEXT,
|
|
* 'qbs2' => PARAM_TEXT,
|
|
* 'qbs3' => PARAM_TEXT,
|
|
* ... and more qbs keys up to core_question\local\bank\view::MAX_SORTS ...
|
|
* ];
|
|
*
|
|
* @param string $edittab Code for this edit tab
|
|
* @param string $baseurl The name of the script calling this funciton. For examle 'qusetion/edit.php'.
|
|
* @param array $params The provided parameters to construct the resources with.
|
|
* @param int $defaultquestionsperpage number of questions per page, if not given in the URL.
|
|
* @return array $thispageurl, $contexts, $cmid, $cm, $module, $pagevars
|
|
*/
|
|
function question_build_edit_resources($edittab, $baseurl, $params,
|
|
$defaultquestionsperpage = DEFAULT_QUESTIONS_PER_PAGE) {
|
|
global $DB;
|
|
|
|
$thispageurl = new moodle_url($baseurl);
|
|
$thispageurl->remove_all_params(); // We are going to explicity add back everything important - this avoids unwanted params from being retained.
|
|
|
|
$cleanparams = [
|
|
'sortdata' => [],
|
|
'filter' => null
|
|
];
|
|
$paramtypes = [
|
|
'cmid' => PARAM_INT,
|
|
'courseid' => PARAM_INT,
|
|
'qpage' => PARAM_INT,
|
|
'cat' => PARAM_SEQUENCE,
|
|
'category' => PARAM_SEQUENCE,
|
|
'qperpage' => PARAM_INT,
|
|
'cpage' => PARAM_INT,
|
|
];
|
|
|
|
foreach ($paramtypes as $name => $type) {
|
|
if (isset($params[$name])) {
|
|
$cleanparams[$name] = clean_param($params[$name], $type);
|
|
} else {
|
|
$cleanparams[$name] = null;
|
|
}
|
|
}
|
|
|
|
if (!empty($params['filter'])) {
|
|
if (!is_array($params['filter'])) {
|
|
$params['filter'] = json_decode($params['filter'], true);
|
|
}
|
|
$cleanparams['filter'] = $params['filter'];
|
|
}
|
|
|
|
if (isset($params['sortdata'])) {
|
|
$cleanparams['sortdata'] = clean_param_array($params['sortdata'], PARAM_INT);
|
|
}
|
|
|
|
$cmid = $cleanparams['cmid'];
|
|
$courseid = $cleanparams['courseid'];
|
|
$qpage = $cleanparams['qpage'] ?: -1;
|
|
$cat = $cleanparams['cat'] ?: 0;
|
|
$category = $cleanparams['category'] ?: 0;
|
|
$qperpage = $cleanparams['qperpage'];
|
|
$cpage = $cleanparams['cpage'] ?: 1;
|
|
|
|
if (is_null($cmid) && is_null($courseid)) {
|
|
throw new \moodle_exception('Must provide a cmid or courseid');
|
|
}
|
|
|
|
if ($cmid) {
|
|
list($module, $cm) = get_module_from_cmid($cmid);
|
|
$courseid = $cm->course;
|
|
$thispageurl->params(compact('cmid'));
|
|
$thiscontext = context_module::instance($cmid);
|
|
} else {
|
|
$module = null;
|
|
$cm = null;
|
|
$thispageurl->params(compact('courseid'));
|
|
$thiscontext = context_course::instance($courseid);
|
|
}
|
|
|
|
if (defined('AJAX_SCRIPT') && AJAX_SCRIPT) {
|
|
// For AJAX, we don't need to set up the course page for output.
|
|
require_login();
|
|
} else {
|
|
require_login($courseid, false, $cm);
|
|
}
|
|
|
|
if ($thiscontext){
|
|
$contexts = new core_question\local\bank\question_edit_contexts($thiscontext);
|
|
$contexts->require_one_edit_tab_cap($edittab);
|
|
} else {
|
|
$contexts = null;
|
|
}
|
|
|
|
$pagevars['qpage'] = $qpage;
|
|
|
|
// Pass 'cat' from page to page and when 'category' comes from a drop down menu
|
|
// then we also reset the qpage so we go to page 1 of
|
|
// a new cat.
|
|
if ($category && $category != $cat) { // Is this a move to a new category?
|
|
$pagevars['cat'] = $category;
|
|
$pagevars['qpage'] = 0;
|
|
} else {
|
|
$pagevars['cat'] = $cat; // If empty will be set up later.
|
|
}
|
|
|
|
if ($pagevars['cat']){
|
|
$thispageurl->param('cat', $pagevars['cat']);
|
|
}
|
|
|
|
if (strpos($baseurl, '/question/') === 0) {
|
|
navigation_node::override_active_url($thispageurl);
|
|
}
|
|
|
|
if ($pagevars['qpage'] > -1) {
|
|
$thispageurl->param('qpage', $pagevars['qpage']);
|
|
} else {
|
|
$pagevars['qpage'] = 0;
|
|
}
|
|
|
|
if ($defaultquestionsperpage == DEFAULT_QUESTIONS_PER_PAGE) {
|
|
$pagevars['qperpage'] = question_set_or_get_user_preference(
|
|
'qperpage', $qperpage, DEFAULT_QUESTIONS_PER_PAGE, $thispageurl);
|
|
} else {
|
|
$pagevars['qperpage'] = $qperpage ?? $defaultquestionsperpage;
|
|
}
|
|
|
|
$defaultcategory = question_make_default_categories($contexts->all());
|
|
|
|
$contextlistarr = [];
|
|
foreach ($contexts->having_one_edit_tab_cap($edittab) as $context){
|
|
$contextlistarr[] = "'{$context->id}'";
|
|
}
|
|
$contextlist = join(' ,', $contextlistarr);
|
|
if (!empty($pagevars['cat'])){
|
|
$catparts = explode(',', $pagevars['cat']);
|
|
if (!$catparts[0] || (false !== array_search($catparts[1], $contextlistarr)) ||
|
|
!$DB->count_records_select("question_categories", "id = ? AND contextid = ?", array($catparts[0], $catparts[1]))) {
|
|
throw new \moodle_exception('invalidcategory', 'question');
|
|
}
|
|
} else {
|
|
$category = $defaultcategory;
|
|
$pagevars['cat'] = "{$category->id},{$category->contextid}";
|
|
}
|
|
|
|
// Category list page.
|
|
$pagevars['cpage'] = $cpage;
|
|
if ($pagevars['cpage'] != 1){
|
|
$thispageurl->param('cpage', $pagevars['cpage']);
|
|
}
|
|
|
|
if ($cleanparams['filter']) {
|
|
$pagevars['filter'] = $cleanparams['filter'];
|
|
$thispageurl->param('filter', json_encode($cleanparams['filter']));
|
|
}
|
|
$pagevars['tabname'] = $edittab;
|
|
|
|
// Sort parameters.
|
|
$pagevars['sortdata'] = $cleanparams['sortdata'];
|
|
foreach ($pagevars['sortdata'] as $sortname => $sortorder) {
|
|
$thispageurl->param('sortdata[' . $sortname . ']', $sortorder);
|
|
}
|
|
|
|
// Enforce ALL as the only allowed top-level join type, so we can't bypass filtering by category.
|
|
$pagevars['jointype'] = datafilter::JOINTYPE_ALL;
|
|
|
|
return array($thispageurl, $contexts, $cmid, $cm, $module, $pagevars);
|
|
}
|
|
|
|
/**
|
|
* Get the category id from $pagevars.
|
|
* @param array $pagevars from {@link question_edit_setup()}.
|
|
* @return int the category id.
|
|
*/
|
|
function question_get_category_id_from_pagevars(array $pagevars) {
|
|
list($questioncategoryid) = explode(',', $pagevars['cat']);
|
|
return $questioncategoryid;
|
|
}
|
|
|
|
/**
|
|
* Get a particular question preference that is also stored as a user preference.
|
|
* If the the value is given in the GET/POST request, then that value is used,
|
|
* and the user preference is updated to that value. Otherwise, the last set
|
|
* value of the user preference is used, or if it has never been set the default
|
|
* passed to this function.
|
|
*
|
|
* @param string $param the param name. The URL parameter set, and the GET/POST
|
|
* parameter read. The user_preference name is 'question_bank_' . $param.
|
|
* @param mixed $default The default value to use, if not otherwise set.
|
|
* @param int $type one of the PARAM_... constants.
|
|
* @param moodle_url $thispageurl if the value has been explicitly set, we add
|
|
* it to this URL.
|
|
* @return mixed the parameter value to use.
|
|
*/
|
|
function question_get_display_preference($param, $default, $type, $thispageurl) {
|
|
$submittedvalue = optional_param($param, null, $type);
|
|
return question_set_or_get_user_preference($param, $submittedvalue, $default, $thispageurl);
|
|
}
|
|
|
|
/**
|
|
* Get a user preference by name or set the user preference to a given value.
|
|
*
|
|
* If $value is null then the function will only attempt to retrieve the
|
|
* user preference requested by $name. If no user preference is found then the
|
|
* $default value will be returned. In this case the user preferences are not
|
|
* modified and nor are the params on $thispageurl.
|
|
*
|
|
* If $value is anything other than null then the function will set the user
|
|
* preference $name to the provided $value and will also set it as a param
|
|
* on $thispageurl.
|
|
*
|
|
* @param string $name The user_preference name is 'question_bank_' . $name.
|
|
* @param mixed $value The preference value.
|
|
* @param mixed $default The default value to use, if not otherwise set.
|
|
* @param moodle_url $thispageurl if the value has been explicitly set, we add
|
|
* it to this URL.
|
|
* @return mixed the parameter value to use.
|
|
*/
|
|
function question_set_or_get_user_preference($name, $value, $default, $thispageurl) {
|
|
if (is_null($value)) {
|
|
return get_user_preferences('question_bank_' . $name, $default);
|
|
}
|
|
|
|
set_user_preference('question_bank_' . $name, $value);
|
|
$thispageurl->param($name, $value);
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Make sure user is logged in as required in this context.
|
|
*/
|
|
function require_login_in_context($contextorid = null){
|
|
global $DB, $CFG;
|
|
if (!is_object($contextorid)){
|
|
$context = context::instance_by_id($contextorid, IGNORE_MISSING);
|
|
} else {
|
|
$context = $contextorid;
|
|
}
|
|
if ($context && ($context->contextlevel == CONTEXT_COURSE)) {
|
|
require_login($context->instanceid);
|
|
} else if ($context && ($context->contextlevel == CONTEXT_MODULE)) {
|
|
if ($cm = $DB->get_record('course_modules',array('id' =>$context->instanceid))) {
|
|
if (!$course = $DB->get_record('course', array('id' => $cm->course))) {
|
|
throw new \moodle_exception('invalidcourseid');
|
|
}
|
|
require_course_login($course, true, $cm);
|
|
|
|
} else {
|
|
throw new \moodle_exception('invalidcoursemodule');
|
|
}
|
|
} else if ($context && ($context->contextlevel == CONTEXT_SYSTEM)) {
|
|
if (!empty($CFG->forcelogin)) {
|
|
require_login();
|
|
}
|
|
|
|
} else {
|
|
require_login();
|
|
}
|
|
}
|