Newer
Older
// This file is part of Stack - http://stack.maths.ed.ac.uk/
// Stack 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.
//
// Stack 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 Stack. If not, see <http://www.gnu.org/licenses/>.
/**
* Stack question definition class.
*
* @package qtype_stack
* @copyright 2012 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once(__DIR__ . '/stack/input/factory.class.php');
require_once(__DIR__ . '/stack/cas/keyval.class.php');
Matti Harjula
committed
require_once(__DIR__ . '/stack/cas/castext2/castext2_evaluatable.class.php');
require_once(__DIR__ . '/stack/cas/cassecurity.class.php');
require_once($CFG->dirroot . '/question/behaviour/adaptivemultipart/behaviour.php');
require_once(__DIR__ . '/locallib.php');
require_once(__DIR__ . '/questiontype.php');
require_once(__DIR__ . '/stack/cas/secure_loader.class.php');
require_once(__DIR__ . '/stack/prt.class.php');
require_once(__DIR__ . '/stack/prt.evaluatable.class.php');
Matti Harjula
committed
require_once(__DIR__ . '/vle_specific.php');
* Represents a Stack question.
* @copyright 2012 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
class qtype_stack_question extends question_graded_automatically_with_countback
implements question_automatically_gradable_with_multiple_parts {
Chris Sangwin
committed
/**
* @var string STACK specific: Holds the version of the question when it was last saved.
*/
public $stackversion;
/**
* @var string STACK specific: variables, as authored by the teacher.
*/
public $questionvariables;
/**
* @var string STACK specific: variables, as authored by the teacher.
*/
public $questionnote;
/**
* @var string STACK specific: allow a question to carry some description/discussion.
*/
public $questiondescription;
/** @var int one of the FORMAT_... constants */
public $questiondescriptionformat;
/**
* @var string Any specific feedback for this question. This is displayed
* in the 'yellow' feedback area of the question. It can contain PRTfeedback
* tags, but not IEfeedback.
*/
public $specificfeedback;
/** @var int one of the FORMAT_... constants */
/** @var string Feedback that is displayed for any PRT that returns a score of 1. */
public $prtcorrect;
/** @var int one of the FORMAT_... constants */
public $prtcorrectformat;
/** @var string Feedback that is displayed for any PRT that returns a score between 0 and 1. */
public $prtpartiallycorrect;
/** @var int one of the FORMAT_... constants */
public $prtpartiallycorrectformat;
/** @var string Feedback that is displayed for any PRT that returns a score of 0. */
public $prtincorrect;
/** @var int one of the FORMAT_... constants */
public $prtincorrectformat;
/** @var string if set, this is used to control the pseudo-random generation of the seed. */
public $variantsselectionseed;
* @var stack_input[] STACK specific: string name as it appears in the question text => stack_input
public $inputs = array();
* @var stack_potentialresponse_tree_lite[] STACK specific: respones tree number => ...
public $prts = array();
* @var stack_options STACK specific: question-level options.
* @var int[] of seed values that have been deployed.
* @var int STACK specific: seeds Maxima's random number generator.
* @var stack_cas_session2 STACK specific: session of variables.
* @var stack_ast_container[] STACK specific: the teacher's answers for each input.
*/
private $tas;
/**
* @var stack_cas_security the question level common security
* settings, i.e. forbidden keys and wether units are in play.
* Note that the security-object is used to enforce read-only
* identifiers and therefore wether we are dealing with units
* is important to it, as obviously one should not redefine units.
*/
private $security;
Matti Harjula
committed
* @var castext2_evaluatable STACK specific: variant specifying castext fragment.
protected $questionnoteinstantiated = null;
/**
* @var castext2_evaluatable STACK specific.
*/
protected $questiondescriptioninstantiated = null;
Matti Harjula
committed
* @var castext2_evaluatable instantiated version of questiontext.
* Initialised in start_attempt / apply_attempt_state.
*/
public $questiontextinstantiated;
/**
Matti Harjula
committed
* @var castext2_evaluatable instantiated version of specificfeedback.
* Initialised in start_attempt / apply_attempt_state.
*/
public $specificfeedbackinstantiated;
Matti Harjula
committed
* @var castext2_evaluatable instantiated version of generalfeedback.
* Init depends of config.
*/
private $generalfeedbackinstantiated = null;
/**
* @var castext2_evaluatable instantiated version of prtcorrect.
* Initialised in start_attempt / apply_attempt_state.
Matti Harjula
committed
* NOTE: used in rederer.php:standard_prt_feedback() in an uncommon way.
*/
public $prtcorrectinstantiated;
/**
Matti Harjula
committed
* @var castext2_evaluatable instantiated version of prtpartiallycorrect.
* Initialised in start_attempt / apply_attempt_state.
*/
public $prtpartiallycorrectinstantiated;
/**
Matti Harjula
committed
* @var castext2_evaluatable instantiated version of prtincorrect.
* Initialised in start_attempt / apply_attempt_state.
*/
public $prtincorrectinstantiated;
* @var castext2_processor an accesspoint to the question attempt for
* the castext2 post-processing logic for pluginfile url-writing.
*/
public $castextprocessor = null;
Chris Sangwin
committed
/**
* @var array Errors generated at runtime.
Chris Sangwin
committed
* Any errors are stored as the keys to prevent duplicates. Values are ignored.
*/
public $runtimeerrors = array();
/**
* The next three fields cache the results of some expensive computations.
* The chache is only valid for a particular response, so we store the current
* response, so that we can learn the cached information in the result changes.
*/
protected $lastresponse = null;
/**
* @var bool like $lastresponse, but for the $acceptvalid argument to {@link validate_cache()}.
*/
protected $lastacceptvalid = null;
* @var stack_input_state[] input name => stack_input_state.
* This caches the results of validate_student_response for $lastresponse.
*/
protected $inputstates = array();
/**
* @var array prt name => result of evaluate_response, if known.
/**
* @var array set of expensive to evaluate but static things.
*/
public $compiledcache = [];
/**
* Make sure the cache is valid for the current response. If not, clear it.
*
* @param array $response the response.
* @param bool $acceptvalid if this is true, then we will grade things even
* if the corresponding inputs are only VALID, and not SCORE.
protected function validate_cache($response, $acceptvalid = null) {
if (is_null($this->lastresponse)) {
$this->lastresponse = $response;
$this->lastacceptvalid = $acceptvalid;
// We really need the PHP === here, as "0.040" == "0.04", even as strings.
// See https://stackoverflow.com/questions/80646/ for details.
if ($this->lastresponse === $response && (
$this->lastacceptvalid === null || $acceptvalid === null || $this->lastacceptvalid === $acceptvalid)) {
if ($this->lastacceptvalid === null) {
$this->lastacceptvalid = $acceptvalid;
}
return; // Cache is good.
}
// Clear the cache.
$this->lastresponse = $response;
$this->lastacceptvalid = $acceptvalid;
$this->inputstates = array();
$this->prtresults = array();
}
/**
* @return bool do any of the inputs in this question require the student
*/
protected function any_inputs_require_validation() {
foreach ($this->inputs as $name => $input) {
if ($input->requires_validation()) {
return true;
}
}
return false;
}
public function make_behaviour(question_attempt $qa, $preferredbehaviour) {
if (empty($this->inputs)) {
return question_engine::make_behaviour('informationitem', $qa, $preferredbehaviour);
}
if (empty($this->prts)) {
return question_engine::make_behaviour('manualgraded', $qa, $preferredbehaviour);
}
if (!empty($this->inputs)) {
foreach ($this->inputs as $input) {
if ($input->get_extra_option('manualgraded')) {
return question_engine::make_behaviour('manualgraded', $qa, $preferredbehaviour);
}
}
}
if ($preferredbehaviour == 'adaptive' || $preferredbehaviour == 'adaptivenopenalty') {
return question_engine::make_behaviour('adaptivemultipart', $qa, $preferredbehaviour);
}
if ($preferredbehaviour == 'deferredfeedback' && $this->any_inputs_require_validation()) {
return question_engine::make_behaviour('dfexplicitvaildate', $qa, $preferredbehaviour);
}
if ($preferredbehaviour == 'deferredcbm' && $this->any_inputs_require_validation()) {
return question_engine::make_behaviour('dfcbmexplicitvaildate', $qa, $preferredbehaviour);
}
return parent::make_behaviour($qa, $preferredbehaviour);
}
public function start_attempt(question_attempt_step $step, $variant) {
// Work out the right seed to use.
if (!is_null($this->seed)) {
// This empty if statement is a hack, but if seed has already been set, then use that.
// This is used by the questiontestrun.php script to allow non-deployed
// variants to be browsed.
} else if (!$this->has_random_variants()) {
// Randomisation not used.
$this->seed = 1;
} else if (!empty($this->deployedseeds)) {
// Question has a fixed number of variants.
$this->seed = $this->deployedseeds[$variant - 1] + 0;
// Don't know why this is coming out as a string. + 0 converts to int.
} else {
// This question uses completely free randomisation.
$this->seed = $variant;
}
$step->set_qt_var('_seed', $this->seed);
$this->initialise_question_from_seed();
}
/**
* Once we know the random seed, we can initialise all the other parts of the question.
*/
public function initialise_question_from_seed() {
// We can detect a logically faulty question by checking if the cache can
// return anything if it can't then we can simply skip to the output of errors.
if ($this->get_cached('units') !== null) {
// Build up the question session out of all the bits that need to go into it.
// 1. question variables.
$session = new stack_cas_session2([], $this->options, $this->seed);
Matti Harjula
committed
Matti Harjula
committed
// If we are using localisation we should tell the CAS side logic about it.
// For castext rendering and other tasks.
if (count($this->get_cached('langs')) > 0) {
$ml = new stack_multilang();
$selected = $ml->pick_lang($this->get_cached('langs'));
$session->add_statement(new stack_secure_loader('%_STACK_LANG:' .
stack_utils::php_string_to_maxima_string($selected), 'language setting'), false);
Matti Harjula
committed
}
// Construct the security object. But first units declaration into the session.
$units = (boolean) $this->get_cached('units');
// If we have units we might as well include the units declaration in the session.
// To simplify authors work and remove the need to call that long function.
// TODO: Maybe add this to the preable to save lines, but for now documented here.
if ($units) {
$session->add_statement(new stack_secure_loader('stack_unit_si_declare(true)',
'automatic unit declaration'), false);
}
if ($this->get_cached('preamble-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('preamble-qv'), 'preamble'));
}
// Context variables should be first.
if ($this->get_cached('contextvariables-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('contextvariables-qv'), '/qv'));
}
if ($this->get_cached('statement-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('statement-qv'), '/qv'));
// Note that at this phase the security object has no "words".
// The student's answer may not contain any of the variable names with which
// the teacher has defined question variables. Otherwise when it is evaluated
// in a PRT, the student's answer will take these values. If the teacher defines
// 'ta' to be the answer, the student could type in 'ta'! We forbid this.
// TODO: shouldn't we also protect variables used in PRT logic? Feedback vars
// and so on?
$forbiddenkeys = array();
if ($this->get_cached('forbiddenkeys') !== null) {
$forbiddenkeys = $this->get_cached('forbiddenkeys');
}
$this->security = new stack_cas_security($units, '', '', $forbiddenkeys);
// The session to keep. Note we do not need to reinstantiate the teachers answers.
$sessiontokeep = new stack_cas_session2($session->get_session(), $this->options, $this->seed);
// 2. correct answer for all inputs.
foreach ($this->inputs as $name => $input) {
$cs = stack_ast_container::make_from_teacher_source($input->get_teacher_answer(),
'', $this->security);
$this->tas[$name] = $cs;
$session->add_statement($cs);
}
Chris Sangwin
committed
// Check for signs of errors.
if ($this->get_cached('static-castext-strings') === null) {
throw new stack_exception(implode('; ', array_keys($this->runtimeerrors)));
}
Matti Harjula
committed
// 3.0 setup common CASText2 staticreplacer.
$static = new castext2_static_replacer($this->get_cached('static-castext-strings'));
// 3. CAS bits inside the question text.
Matti Harjula
committed
$questiontext = castext2_evaluatable::make_from_compiled($this->get_cached('castext-qt'), '/qt', $static);
if ($questiontext->requires_evaluation()) {
$session->add_statement($questiontext);
}
// 4. CAS bits inside the specific feedback.
Matti Harjula
committed
$feedbacktext = castext2_evaluatable::make_from_compiled($this->get_cached('castext-sf'), '/sf', $static);
if ($feedbacktext->requires_evaluation()) {
$session->add_statement($feedbacktext);
}
// Add the context to the security, needs some unpacking of the cached.
Matti Harjula
committed
if ($this->get_cached('security-context') === null) {
$this->security->set_context([]);
} else {
Matti Harjula
committed
$this->security->set_context($this->get_cached('security-context'));
Chris Sangwin
committed
// The session to keep. Note we do not need to reinstantiate the teachers answers.
$sessiontokeep = new stack_cas_session2($session->get_session(), $this->options, $this->seed);
// 5. CAS bits inside the question note.
Matti Harjula
committed
$notetext = castext2_evaluatable::make_from_compiled($this->get_cached('castext-qn'), '/qn', $static);
if ($notetext->requires_evaluation()) {
$session->add_statement($notetext);
}
$prtcorrect = castext2_evaluatable::make_from_compiled($this->get_cached('castext-prt-c'),
Matti Harjula
committed
'/pc', $static);
$prtpartiallycorrect = castext2_evaluatable::make_from_compiled($this->get_cached('castext-prt-pc'),
Matti Harjula
committed
'/pp', $static);
$prtincorrect = castext2_evaluatable::make_from_compiled($this->get_cached('castext-prt-ic'),
Matti Harjula
committed
'/pi', $static);
if ($prtcorrect->requires_evaluation()) {
$session->add_statement($prtcorrect);
}
if ($prtpartiallycorrect->requires_evaluation()) {
$session->add_statement($prtpartiallycorrect);
}
if ($prtincorrect->requires_evaluation()) {
$session->add_statement($prtincorrect);
}
// Now instantiate the session.
if ($session->get_valid()) {
$session->instantiate();
}
if ($session->get_errors()) {
// In previous versions we threw an exception here.
// Upgrade and import stops errors being caught during validation when the question was edited or deployed.
// This breaks bulk testing in a nasty way.
$this->runtimeerrors[$session->get_errors(true)] = true;
}
Chris Sangwin
committed
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
// Finally, store only those values really needed for later.
$this->questiontextinstantiated = $questiontext;
if ($questiontext->get_errors()) {
$s = stack_string('runtimefielderr',
array('field' => stack_string('questiontext'), 'err' => $questiontext->get_errors()));
$this->runtimeerrors[$s] = true;
}
$this->specificfeedbackinstantiated = $feedbacktext;
if ($feedbacktext->get_errors()) {
$s = stack_string('runtimefielderr',
array('field' => stack_string('specificfeedback'), 'err' => $feedbacktext->get_errors()));
$this->runtimeerrors[$s] = true;
}
$this->questionnoteinstantiated = $notetext;
if ($notetext->get_errors()) {
$s = stack_string('runtimefielderr',
array('field' => stack_string('questionnote'), 'err' => $notetext->get_errors()));
$this->runtimeerrors[$s] = true;
}
$this->prtcorrectinstantiated = $prtcorrect;
$this->prtpartiallycorrectinstantiated = $prtpartiallycorrect;
$this->prtincorrectinstantiated = $prtincorrect;
$this->session = $sessiontokeep;
if ($sessiontokeep->get_errors()) {
$s = stack_string('runtimefielderr',
array('field' => stack_string('questionvariables'), 'err' => $sessiontokeep->get_errors(true)));
$this->runtimeerrors[$s] = true;
}
// Allow inputs to update themselves based on the model answers.
$this->adapt_inputs();
// It is quite possible that questions will, legitimately, throw some kind of error.
// For example, if one of the question variables is 1/0.
// This should not be a show stopper.
// Something has gone wrong here, and the student will be shown nothing.
$s = html_writer::tag('span', stack_string('runtimeerror'), array('class' => 'stackruntimeerrror'));
$errmsg = '';
foreach ($this->runtimeerrors as $key => $val) {
$errmsg .= html_writer::tag('li', $key);
$s .= html_writer::tag('ul', $errmsg);
// So we have this logic where a raw string needs to turn to a CASText2 object.
// As we do not know what it contains we escape it.
Matti Harjula
committed
$this->questiontextinstantiated = castext2_evaluatable::make_from_source('[[escape]]' . $s . '[[/escape]]', '/qt');
// It is a static string and by calling this we make it look like it was evaluated.
Matti Harjula
committed
$this->questiontextinstantiated->requires_evaluation();
// Do some setup for the features that do not work.
$this->security = new stack_cas_security();
$this->tas = [];
$this->session = new stack_cas_session2([]);
}
public function apply_attempt_state(question_attempt_step $step) {
$this->seed = (int) $step->get_qt_var('_seed');
$this->initialise_question_from_seed();
}
/**
* Give all the input elements a chance to configure themselves given the
* teacher's model answers.
*/
protected function adapt_inputs() {
foreach ($this->inputs as $name => $input) {
// TODO: again should we give the whole thing to the input.
$teacheranswer = '';
if ($this->tas[$name]->is_correctly_evaluated()) {
$teacheranswer = $this->tas[$name]->get_value();
}
$input->adapt_to_model_answer($teacheranswer);
Chris Sangwin
committed
if ($this->get_cached('contextvariables-qv') !== null) {
Matti Harjula
committed
$input->add_contextsession(new stack_secure_loader($this->get_cached('contextvariables-qv'), '/qv'));
Chris Sangwin
committed
}
/**
* Get the cattext for a hint, instantiated within the question's session.
* @param question_hint $hint the hint.
* @return stack_cas_text the castext.
*/
public function get_hint_castext(question_hint $hint) {
Matti Harjula
committed
// TODO: These are not currently cached as compiled fragments, maybe they should be.
$hinttext = castext2_evaluatable::make_from_source($hint->hint, 'hint');
Matti Harjula
committed
$session = null;
if ($this->session === null) {
$session = new stack_cas_session2([], $this->options, $this->seed);
} else {
$session = new stack_cas_session2($this->session->get_session(), $this->options, $this->seed);
}
if (count($this->get_cached('langs')) > 0) {
$ml = new stack_multilang();
$selected = $ml->pick_lang($this->get_cached('langs'));
$session->add_statement(new stack_secure_loader('%_STACK_LANG:' .
stack_utils::php_string_to_maxima_string($selected), 'language setting'), false);
}
Matti Harjula
committed
$session->add_statement($hinttext);
$session->instantiate();
if ($hinttext->get_errors()) {
$this->runtimeerrors[$hinttext->get_errors()] = true;
/**
* Get the cattext for the general feedback, instantiated within the question's session.
* @return stack_cas_text the castext.
*/
public function get_generalfeedback_castext() {
Matti Harjula
committed
// Could be that this is instantiated already.
if ($this->generalfeedbackinstantiated !== null) {
return $this->generalfeedbackinstantiated;
}
// We can have a failed question.
if ($this->get_cached('castext-gf') === null) {
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_compiled('"Broken question."', '/gf',
new castext2_static_replacer([])); // This mainly for the bulk-test script.
$ct->requires_evaluation(); // Makes it as if it were evaluated.
return $ct;
Matti Harjula
committed
}
$this->generalfeedbackinstantiated = castext2_evaluatable::make_from_compiled($this->get_cached('castext-gf'),
Matti Harjula
committed
'/gf', new castext2_static_replacer($this->get_cached('static-castext-strings')));
Matti Harjula
committed
// Might not require any evaluation anyway.
if (!$this->generalfeedbackinstantiated->requires_evaluation()) {
return $this->generalfeedbackinstantiated;
}
// Init a session with question-variables and the related details.
Matti Harjula
committed
$session = new stack_cas_session2([], $this->options, $this->seed);
if ($this->get_cached('preamble-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('preamble-qv'), 'preamble'));
}
if ($this->get_cached('contextvariables-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('contextvariables-qv'), '/qv'));
Matti Harjula
committed
}
if ($this->get_cached('statement-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('statement-qv'), '/qv'));
Matti Harjula
committed
}
// Then add the general-feedback code.
$session->add_statement($this->generalfeedbackinstantiated);
$session->instantiate();
Matti Harjula
committed
if ($this->generalfeedbackinstantiated->get_errors()) {
$this->runtimeerrors[$this->generalfeedbackinstantiated->get_errors()] = true;
Matti Harjula
committed
return $this->generalfeedbackinstantiated;
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
/**
* Get the cattext for the question description, instantiated within the question's session.
* @return stack_cas_text the castext.
*/
public function get_questiondescription_castext() {
// Could be that this is instantiated already.
if ($this->questiondescriptioninstantiated !== null) {
return $this->questiondescriptioninstantiated;
}
// We can have a failed question.
if ($this->get_cached('castext-gf') === null) {
$ct = castext2_evaluatable::make_from_compiled('"Broken question."', '/gf',
new castext2_static_replacer([])); // This mainly for the bulk-test script.
$ct->requires_evaluation(); // Makes it as if it were evaluated.
return $ct;
}
$this->questiondescriptioninstantiated = castext2_evaluatable::make_from_compiled($this->get_cached('castext-qd'),
'/gf', new castext2_static_replacer($this->get_cached('static-castext-strings')));
// Might not require any evaluation anyway.
if (!$this->questiondescriptioninstantiated->requires_evaluation()) {
return $this->questiondescriptioninstantiated;
}
// Init a session with question-variables and the related details.
$session = new stack_cas_session2([], $this->options, $this->seed);
if ($this->get_cached('preamble-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('preamble-qv'), 'preamble'));
}
if ($this->get_cached('contextvariables-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('contextvariables-qv'), '/qv'));
}
if ($this->get_cached('statement-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('statement-qv'), '/qv'));
}
// Then add the description code.
$session->add_statement($this->questiondescriptioninstantiated);
$session->instantiate();
if ($this->questiondescriptioninstantiated->get_errors()) {
$this->runtimeerrors[$this->questiondescriptioninstantiated->get_errors()] = true;
}
return $this->questiondescriptioninstantiated;
}
/**
* We need to make sure the inputs are displayed in the order in which they
* occur in the question text. This is not necessarily the order in which they
* are listed in the array $this->inputs.
*/
public function format_correct_response($qa) {
Matti Harjula
committed
$inputs = stack_utils::extract_placeholders($this->questiontextinstantiated->get_rendered(), 'input');
foreach ($inputs as $name) {
$input = $this->inputs[$name];
Matti Harjula
committed
$feedback .= html_writer::tag('p', $input->get_teacher_answer_display($this->tas[$name]->get_dispvalue(),
$this->tas[$name]->get_latex()));
return stack_ouput_castext($feedback);
public function get_expected_data() {
$expected = array();
foreach ($this->inputs as $input) {
$expected += $input->get_expected_data();
}
return $expected;
}
public function get_question_summary() {
Matti Harjula
committed
if ($this->questionnoteinstantiated !== null &&
'' !== $this->questionnoteinstantiated->get_rendered()) {
return $this->questionnoteinstantiated->get_rendered();
return stack_string('questionnote_missing');
public function summarise_response(array $response) {
Chris Sangwin
committed
// Provide seed information on student's version via the normal moodle quiz report.
$bits = array('Seed: ' . $this->seed);
Chris Sangwin
committed
foreach ($this->inputs as $name => $input) {
$state = $this->get_input_state($name, $response);
if (stack_input::BLANK != $state->status) {
$bits[] = $input->summarise_response($name, $state, $response);
Chris Sangwin
committed
// Add in the answer note for this response.
foreach ($this->prts as $name => $prt) {
$state = $this->get_prt_result($name, $response, false);
$note = implode(' | ', array_map('trim', $state->get_answernotes()));
Chris Sangwin
committed
$score = '';
Chris Sangwin
committed
if (trim($note) == '') {
Chris Sangwin
committed
$note = '!';
} else {
Chris Sangwin
committed
$score = "# = " . $state->get_score();
if ($prt->is_formative()) {
$score .= ' [formative]';
}
$score .= " | ";
Chris Sangwin
committed
}
if ($state->get_errors()) {
$score = '[RUNTIME_ERROR] ' . $score . implode("|", $state->get_errors());
Chris Sangwin
committed
}
Chris Sangwin
committed
$score = '[RUNTIME_FV_ERROR] ' . $score . implode("|", $state->get_fverrors()) . ' | ';
Chris Sangwin
committed
}
Chris Sangwin
committed
$bits[] = $name . ": " . $score . $note;
Chris Sangwin
committed
}
return implode('; ', $bits);
public function summarise_response_data(array $response) {
$bits = array();
foreach ($this->inputs as $name => $input) {
$state = $this->get_input_state($name, $response);
$bits[$name] = $state->status;
}
return $bits;
}
public function get_correct_response() {
Chris Sangwin
committed
$teacheranswer = array();
if ($this->runtimeerrors || $this->get_cached('units') === null) {
return [];
}
foreach ($this->inputs as $name => $input) {
$input->get_correct_response($this->tas[$name]->get_dispvalue()));
}
return $teacheranswer;
}
public function is_same_response(array $prevresponse, array $newresponse) {
foreach ($this->get_expected_data() as $name => $notused) {
if (!question_utils::arrays_same_at_key_missing_is_blank(
$prevresponse, $newresponse, $name)) {
return false;
}
}
return true;
}
public function is_same_response_for_part($index, array $prevresponse, array $newresponse) {
$previnput = $this->get_prt_input($index, $prevresponse, true);
$newinput = $this->get_prt_input($index, $newresponse, true);
return $this->is_same_prt_input($index, $previnput, $newinput);
}
/**
* Get the results of validating one of the input elements.
* @param string $name the name of one of the input elements.
* @param array $response the response, in Maxima format.
* @param bool $rawinput the response in raw form. Needs converting to Maxima format by the input.
* @return stack_input_state|string the result of calling validate_student_response() on the input.
public function get_input_state($name, $response, $rawinput=false) {
$this->validate_cache($response, null);
if (array_key_exists($name, $this->inputstates)) {
return $this->inputstates[$name];
}
$lang = null;
if ($this->get_cached('langs') !== null && count($this->get_cached('langs')) > 0) {
$ml = new stack_multilang();
$lang = $ml->pick_lang($this->get_cached('langs'));
}
// TODO: we should probably give the whole ast_container to the input.
// Direct access to LaTeX and the AST might be handy.
if (array_key_exists($name, $this->tas)) {
if ($this->tas[$name]->is_correctly_evaluated()) {
$teacheranswer = $this->tas[$name]->get_value();
}
$qv = [];
$qv['preamble-qv'] = $this->get_cached('preamble-qv');
$qv['contextvariables-qv'] = $this->get_cached('contextvariables-qv');
$qv['statement-qv'] = $this->get_cached('statement-qv');
Chris Sangwin
committed
$this->inputstates[$name] = $this->inputs[$name]->validate_student_response(
$response, $this->options, $teacheranswer, $this->security, $rawinput,
$this->castextprocessor, $qv, $lang);
Chris Sangwin
committed
return $this->inputstates[$name];
}
return '';
/**
* @param array $response the current response being processed.
* @return boolean whether any of the inputs are blank.
*/
public function is_any_input_blank(array $response) {
foreach ($this->inputs as $name => $input) {
if (stack_input::BLANK == $this->get_input_state($name, $response)->status) {
return true;
}
}
return false;
}
public function is_any_part_invalid(array $response) {
// Invalid if any input is invalid, ...
foreach ($this->inputs as $name => $input) {
if (stack_input::INVALID == $this->get_input_state($name, $response)->status) {
return true;
}
}
// ... or any PRT gives an error.
foreach ($this->prts as $name => $prt) {
$result = $this->get_prt_result($name, $response, false);
if ($result->get_errors()) {
return true;
}
}
public function is_complete_response(array $response) {
// If all PRTs are gradable, then the question is complete. Optional inputs may be blank.
foreach ($this->prts as $prt) {
// Formative PRTs do not contribute to complete responses.
if (!$prt->is_formative() && !$this->can_execute_prt($prt, $response, false)) {
return false;
}
}
// If there are no PRTs, then check that all inputs are complete.
if (!$this->prts) {
foreach ($this->inputs as $name => $notused) {
if (stack_input::SCORE != $this->get_input_state($name, $response)->status) {
return false;
}
}
}
}
public function is_gradable_response(array $response) {
// Manually graded answers are always gradable.
if (!empty($this->inputs)) {
foreach ($this->inputs as $input) {
if ($input->get_extra_option('manualgraded')) {
return true;
}
}
}
// If any PRT is gradable, then we can grade the question.
Chris Sangwin
committed
foreach ($this->prts as $index => $prt) {
// Whether formative PRTs can be executed is not relevant to gradability.
if (!$prt->is_formative() && $this->can_execute_prt($prt, $response, true)) {
return true;
}
Chris Sangwin
committed
}
// In the case of no PRTs, questions are in state "is_gradable" if we have
// at least one input in the "score" or "valid" state.
if ($noprts) {
foreach ($this->inputstates as $key => $inputstate) {
if ($inputstate->status == 'score' || $inputstate->status == 'valid') {
return true;
}
}
}
// Otherwise we are not "is_gradable".
}
public function get_validation_error(array $response) {
if ($this->is_any_part_invalid($response)) {
// There will already be a more specific validation error displayed.
return '';
} else if ($this->is_any_input_blank($response)) {
return stack_string('pleaseananswerallparts');
return stack_string('pleasecheckyourinputs');
}
public function grade_response(array $response) {
// If we have one or more notes input which needs manual grading, then mark it as needs grading.
if (!empty($this->inputs)) {
foreach ($this->inputs as $input) {
if ($input->get_extra_option('manualgraded')) {
return question_state::$needsgrading;
}
}
}
foreach ($this->prts as $name => $prt) {
if (!$prt->is_formative()) {
$results = $this->get_prt_result($name, $response, true);
$fraction += $results->get_fraction();
}
}
return array($fraction, question_state::graded_state_for_fraction($fraction));
protected function is_same_prt_input($index, $prtinput1, $prtinput2) {
foreach ($this->get_cached('required')[$this->prts[$index]->get_name()] as $name => $ignore) {
if (!question_utils::arrays_same_at_key_missing_is_blank($prtinput1, $prtinput2, $name)) {
return false;
}
}
return true;
}
public function get_parts_and_weights() {
$weights = array();
foreach ($this->prts as $index => $prt) {
if (!$prt->is_formative()) {
$weights[$index] = $prt->get_value();
}
}
return $weights;
}
public function grade_parts_that_can_be_graded(array $response, array $lastgradedresponses, $finalsubmit) {
$partresults = array();
// At the moment, this method is not written as efficiently as it might
// be in terms of caching. For now I will be happy it computes the right score.
// Once we are confident enough, we can try to optimise.
foreach ($this->prts as $index => $prt) {
// Some optimisation now hidden behind this, it will eval all PRTs
// of the question for this input.
$results = $this->get_prt_result($index, $response, $finalsubmit);
$partresults[$index] = new qbehaviour_adaptivemultipart_part_result($index, null, null, true);
if (array_key_exists($index, $lastgradedresponses)) {
$lastresponse = $lastgradedresponses[$index];
} else {
$lastresponse = array();
}
$lastinput = $this->get_prt_input($index, $lastresponse, $finalsubmit);
$prtinput = $this->get_prt_input($index, $response, $finalsubmit);
if ($this->is_same_prt_input($index, $lastinput, $prtinput)) {
continue;
}
$partresults[$index] = new qbehaviour_adaptivemultipart_part_result(
$index, $results->get_score(), $results->get_penalty());
}
return $partresults;
}
public function compute_final_grade($responses, $totaltries) {
// This method is used by the interactive behaviour to compute the final
// grade after all the tries are done.
// At the moment, this method is not written as efficiently as it might
// be in terms of caching. For now I am happy it computes the right score.
// Once we are confident enough, we could try switching the nesting
// of the loops to increase efficiency.
// TODO: switch the nesting, now that the eval is by response and not by PRT.
// Current CAS-cache helps but it is wasted cycles to go to it so many times.
$fraction = 0;
foreach ($this->prts as $index => $prt) {
if ($prt->is_formative()) {
continue;
}
$accumulatedpenalty = 0;
$lastinput = array();
$penaltytoapply = null;
$results = new stdClass();
$results->fraction = 0;
$frac = 0;
foreach ($responses as $response) {
$prtinput = $this->get_prt_input($index, $response, true);
if (!$this->is_same_prt_input($index, $lastinput, $prtinput)) {
$penaltytoapply = $accumulatedpenalty;
$lastinput = $prtinput;
}
if ($this->can_execute_prt($this->prts[$index], $response, true)) {
$results = $this->get_prt_result($index, $response, true);
$accumulatedpenalty += $results->get_fractionalpenalty();
$frac = $results->get_fraction();
$fraction += max($frac - $penaltytoapply, 0);
}
return $fraction;
Chris Sangwin
committed
* Do we have all the necessary inputs to execute one of the potential response trees?
Chris Sangwin
committed
* @param stack_potentialresponse_tree_lite $prt the tree in question.
* @param array $response the response.
* @param bool $acceptvalid if this is true, then we will grade things even
* if the corresponding inputs are only VALID, and not SCORE.
* @return bool can this PRT be executed for that response.
protected function has_necessary_prt_inputs(stack_potentialresponse_tree_lite $prt, $response, $acceptvalid) {
Chris Sangwin
committed
// Some kind of time-time error in the question, so bail here.
if ($this->get_cached('required') === null) {
return false;
}
foreach ($this->get_cached('required')[$prt->get_name()] as $name => $ignore) {
$status = $this->get_input_state($name, $response)->status;
if (!(stack_input::SCORE == $status || ($acceptvalid && stack_input::VALID == $status))) {
/**
* Do we have all the necessary inputs to execute one of the potential response trees?
Chris Sangwin
committed
* @param stack_potentialresponse_tree_lite $prt the tree in question.
* @param array $response the response.
* @param bool $acceptvalid if this is true, then we will grade things even
* if the corresponding inputs are only VALID, and not SCORE.
* @return bool can this PRT be executed for that response.
*/
protected function can_execute_prt(stack_potentialresponse_tree_lite $prt, $response, $acceptvalid) {
// The only way to find out is to actually try evaluating it. This calls
// has_necessary_prt_inputs, and then does the computation, which ensures
// there are no CAS errors.
$result = $this->get_prt_result($prt->get_name(), $response, $acceptvalid);
return $result->is_evaluated() && !$result->get_errors();
/**
* Extract the input for a given PRT from a full response.
* @param string $index the name of the PRT.
* @param array $response the full response data.
* @param bool $acceptvalid if this is true, then we will grade things even
* if the corresponding inputs are only VALID, and not SCORE.
* @return array the input required by that PRT.
*/
protected function get_prt_input($index, $response, $acceptvalid) {
if (!array_key_exists($index, $this->prts)) {
$msg = '"' . $this->name . '" (' . $this->id . ') seed = ' .
$this->seed . ' and STACK version = ' . $this->stackversion;
throw new stack_exception ("get_prt_input called for PRT " . $index ." which does not exist in question " . $msg);
}
$prt = $this->prts[$index];
$prtinput = array();
foreach ($this->get_cached('required')[$prt->get_name()] as $name => $ignore) {
$state = $this->get_input_state($name, $response);
if (stack_input::SCORE == $state->status || ($acceptvalid && stack_input::VALID == $state->status)) {
$val = $state->contentsmodified;
if ($state->simp === true) {
}
$prtinput[$name] = $val;
}
}
return $prtinput;
}
/**
* Evaluate a PRT for a particular response.
* @param string $index the index of the PRT to evaluate.
* @param array $response the response to process.
* @param bool $acceptvalid if this is true, then we will grade things even
* if the corresponding inputs are only VALID, and not SCORE.
* @return prt_evaluatable the result from traversing the prt.
public function get_prt_result($index, $response, $acceptvalid) {
$this->validate_cache($response, $acceptvalid);
if (array_key_exists($index, $this->prtresults)) {
return $this->prtresults[$index];
}
// We can end up with a null prt at this point if we have question tests for a deleted PRT.
// Alternatively we have a question that could not be compiled.
if (!array_key_exists($index, $this->prts) || $this->get_cached('units') === null) {
// Bail here with an empty state to avoid a later exception which prevents question test editing.
return new prt_evaluatable('prt_' . $index . '(???)', 1, new castext2_static_replacer([]), array());
// If we do not have inputs for this then no need to continue.
if (!$this->has_necessary_prt_inputs($this->prts[$index], $response, $acceptvalid)) {
$this->prtresults[$index] = new prt_evaluatable($this->get_cached('prt-signature')[$index],
$this->prts[$index]->get_value(),
new castext2_static_replacer($this->get_cached('static-castext-strings')),
$this->get_cached('prt-trace')[$index]);
return $this->prtresults[$index];
}
// First figure out which PRTs can be called.
$prts = [];
$inputs = [];
foreach ($this->prts as $name => $prt) {
if ($this->has_necessary_prt_inputs($prt, $response, $acceptvalid)) {
$prts[$name] = $prt;
$inputs += $this->get_prt_input($name, $response, $acceptvalid);
}
}
// So now we build a session to evaluate all the PRTs.
$session = new stack_cas_session2([], $this->options, $this->seed);
if (count($this->get_cached('langs')) > 0) {
$ml = new stack_multilang();
$selected = $ml->pick_lang($this->get_cached('langs'));
$session->add_statement(new stack_secure_loader('%_STACK_LANG:' .
stack_utils::php_string_to_maxima_string($selected), 'language setting'), false);
}
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
// Construct the security object. But first units declaration into the session.
$units = (boolean) $this->get_cached('units');
// If we have units we might as well include the units declaration in the session.
// To simplify authors work and remove the need to call that long function.
// TODO: Maybe add this to the preable to save lines, but for now documented here.
if ($units) {
$session->add_statement(new stack_secure_loader('stack_unit_si_declare(true)',
'automatic unit declaration'), false);
}
if ($this->get_cached('preamble-qv') !== null) {
$session->add_statement(new stack_secure_loader($this->get_cached('preamble-qv'), 'preamble'));
}
// Add preamble from PRTs as well.
foreach ($this->get_cached('prt-preamble') as $name => $stmt) {
if (isset($prts[$name])) {
$session->add_statement(new stack_secure_loader($stmt, 'preamble PRT: ' . $name));
}
}
// Context variables should be first.
if ($this->get_cached('contextvariables-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('contextvariables-qv'), '/qv'));
}
// Add contextvars from PRTs as well.
foreach ($this->get_cached('prt-contextvariables') as $name => $stmt) {
if (isset($prts[$name])) {
$session->add_statement(new stack_secure_loader($stmt, 'contextvariables PRT: ' . $name));
}
}
if ($this->get_cached('statement-qv') !== null) {
Matti Harjula
committed
$session->add_statement(new stack_secure_loader($this->get_cached('statement-qv'), '/qv'));
}
// Then the definitions of the PRT-functions. Note not just statements for a reason.
foreach ($this->get_cached('prt-definition') as $name => $stmt) {
if (isset($prts[$name])) {
$session->add_statement(new stack_secure_loader($stmt, 'definition PRT: ' . $name));
}
}
Chris Sangwin
committed
// Suppress simplification of raw inputs.
$session->add_statement(new stack_secure_loader('simp:false', 'input-simplification'));
// Now push in the input values and the new _INPUT_STRING.
// Note these have been validated in the input system.
foreach ($inputs as $key => $value) {
$session->add_statement(new stack_secure_loader($key . ':' . $value, 'i/' .
array_search($key, array_keys($this->inputs)) . '/s'));
$is .= ',[' . stack_utils::php_string_to_maxima_string($key) . ',';
if (strpos($value, 'ev(') === 0) { // Unpack the value if we have simp...
$is .= stack_utils::php_string_to_maxima_string(mb_substr($value, 3, -6)) . ']';
$is .= stack_utils::php_string_to_maxima_string($value) . ']';
$is .= ']';
$session->add_statement(new stack_secure_loader($is, 'input-strings'));
// Generate, cache and instantiate the results.
foreach ($this->prts as $name => $prt) {
// Put the input string map in the trace.
$trace = array_merge(array($is . '$', '/* ------------------- */'), $this->get_cached('prt-trace')[$name]);
$p = new prt_evaluatable($this->get_cached('prt-signature')[$name],
$prt->get_value(), new castext2_static_replacer($this->get_cached('static-castext-strings')),
Chris Sangwin
committed
$trace);
// Always make sure it gets called with simp:false.
$session->add_statement(new stack_secure_loader('simp:false', 'prt-simplification'));
$session->add_statement($p);
}
$this->prtresults[$name] = $p;
}
$session->instantiate();
/**
* For a possibly nested array, replace all the values with $newvalue.
* @param string|array $arrayorscalar input array/value.
* @param mixed $newvalue the new value to set.
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
*/
protected function set_value_in_nested_arrays($arrayorscalar, $newvalue) {
if (!is_array($arrayorscalar)) {
return $newvalue;
}
$newarray = array();
foreach ($arrayorscalar as $key => $value) {
$newarray[$key] = $this->set_value_in_nested_arrays($value, $newvalue);
}
return $newarray;
}
/**
* Pollute the question's input state and PRT result caches so that each
* input appears to contain the name of the input, and each PRT feedback
* area displays "Feedback from PRT {name}". Naturally, this method should
* only be used for special purposes, namely the tidyquestion.php script.
*/
public function setup_fake_feedback_and_input_validation() {
// Set the cached input stats as if the user types the input name into each box.
foreach ($this->inputstates as $name => $inputstate) {
$this->inputstates[$name] = new stack_input_state(
$inputstate->status, $this->set_value_in_nested_arrays($inputstate->contents, $name),
$inputstate->contentsmodified, $inputstate->contentsdisplayed, $inputstate->errors, $inputstate->note, '');
}
// Set the cached prt results as if the feedback for each PRT was
// "Feedback from PRT {name}".
foreach ($this->prtresults as $name => $prtresult) {
$prtresult->override_feedback(stack_string('feedbackfromprtx', $name));
* @return bool whether this question uses randomisation.
*/
public function has_random_variants() {
return $this->random_variants_check($this->questionvariables);
}
/**
* @param string Input text (raw keyvals) to check for random functions, or use of stack_seed.
* @return bool Actual test of whether text uses randomisation.
*/
public static function random_variants_check($text) {
return preg_match('~\brand~', $text) || preg_match('~\bmultiselqn~', $text)
|| preg_match('~\bstack_seed~', $text);
public function get_num_variants() {
if (!$this->has_random_variants()) {
// This question does not use randomisation. Only declare one variant.
if (!empty($this->deployedseeds)) {
return count($this->deployedseeds);
}
// Random question without fixed variants. We will use the seed from Moodle raw.
return 1000000;
public function get_variants_selection_seed() {
if (!empty($this->variantsselectionseed)) {
return $this->variantsselectionseed;
} else {
return parent::get_variants_selection_seed();
}
}
public function check_file_access($qa, $options, $component, $filearea, $args, $forcedownload) {
if ($component == 'qtype_stack' && $filearea == 'specificfeedback') {
// Specific feedback files only visibile when the feedback is.
return $options->feedback;
} else if ($component == 'qtype_stack' && in_array($filearea,
array('prtcorrect', 'prtpartiallycorrect', 'prtincorrect'))) {
// This is a bit lax, but anything else is computationally very expensive.
return $options->feedback;
} else if ($component == 'qtype_stack' && in_array($filearea,
array('prtnodefalsefeedback', 'prtnodetruefeedback'))) {
// This is a bit lax, but anything else is computationally very expensive.
return $options->feedback;
} else if ($component == 'question' && $filearea == 'hint') {
return $this->check_hint_file_access($qa, $options, $args);
} else {
return parent::check_file_access($qa, $options, $component, $filearea, $args, $forcedownload);
}
}
public function get_context() {
return context::instance_by_id($this->contextid);
}
protected function has_question_capability($type) {
global $USER;
$context = $this->get_context();
return has_capability("moodle/question:{$type}all", $context) ||
($USER->id == $this->createdby && has_capability("moodle/question:{$type}mine", $context));
}
/* Get the values of all variables which have a key. So, function definitions
* and assignments are ignored by this method. Used to display the values of
* variables used in a question variant. Beware that some functions have side
* effects in Maxima, e.g. orderless. If you use these values you may not get
* the same results as if you recreate the whole session from $this->questionvariables.
*/
public function get_question_session_keyval_representation() {
// After the cached compilation update the session no longer returns these.
// So we will build another session just for this.
// First we replace the compiled statements with the raw keyval statements.
$tmp = $this->session->get_session();
$tmp = array_filter($tmp, function($v) {
return method_exists($v, 'is_correctly_evaluated');
});
$kv = new stack_cas_keyval($this->questionvariables, $this->options, $this->seed);
$kv->get_valid();
$session = $kv->get_session();
$session->add_statements($tmp);
$session->get_valid();
Chris Sangwin
committed
if ($session->get_valid()) {
$session->instantiate();
}
// We always want the values when this method is called.
return $session->get_keyval_representation(true);
/**
* Add all the question variables to a give CAS session. This can be used to
* initialise that session, so expressions can be evaluated in the context of
* the question variables.
* @param stack_cas_session2 $session the CAS session to add the question variables to.
public function add_question_vars_to_session(stack_cas_session2 $session) {
// Question vars will always get added to the beginning of whatever session you give.
$this->session->prepend_to_session($session);
Chris Sangwin
committed
/**
* Enable the renderer to access the teacher's answer in the session.
* TODO: should we give the whole thing?
Chris Sangwin
committed
*/
public function get_ta_for_input(string $vname): string {
Matti Harjula
committed
if (isset($this->tas[$vname]) && $this->tas[$vname]->is_correctly_evaluated()) {
return $this->tas[$vname]->get_value();
}
return '';
Chris Sangwin
committed
}
public function classify_response(array $response) {
$classification = array();
foreach ($this->prts as $index => $prt) {
if ($prt->is_formative()) {
continue;
}
if (!$this->can_execute_prt($prt, $response, true)) {
foreach ($prt->get_nodes_summary() as $nodeid => $choices) {
$classification[$index . '-' . $nodeid] = question_classified_response::no_response();
}
continue;
}
Matti Harjula
committed
$results = $this->get_prt_result($index, $response, true);
$answernotes = implode(' | ', array_map('trim', $results->get_answernotes()));
foreach ($prt->get_nodes_summary() as $nodeid => $choices) {
Chris Sangwin
committed
if (in_array($choices->trueanswernote, $results->get_answernotes())) {
$classification[$index . '-' . $nodeid] = new question_classified_response(
Chris Sangwin
committed
$choices->trueanswernote, $answernotes, $results->get_fraction());
Chris Sangwin
committed
} else if (in_array($choices->falseanswernote, $results->get_answernotes())) {
$classification[$index . '-' . $nodeid] = new question_classified_response(
Chris Sangwin
committed
$choices->falseanswernote, $answernotes, $results->get_fraction());
} else {
$classification[$index . '-' . $nodeid] = question_classified_response::no_response();
}
}
}
return $classification;
}
/**
* Deploy a variant of this question.
* @param int $seed the seed to deploy.
*/
public function deploy_variant($seed) {
$this->qtype->deploy_variant($this->id, $seed);
}
/**
* Un-deploy a variant of this question.
* @param int $seed the seed to un-deploy.
*/
public function undeploy_variant($seed) {
$this->qtype->undeploy_variant($this->id, $seed);
}
/**
* This function is called by the bulk testing script on upgrade.
* This checks if questions use features which have changed.
*/
Chris Sangwin
committed
public function validate_against_stackversion($context) {
Chris Sangwin
committed
$qfields = array('questiontext', 'questionvariables', 'questionnote', 'questiondescription',
'specificfeedback', 'generalfeedback');
$stackversion = (int) $this->stackversion;
// Things no longer allowed in questions.
$patterns = array(
array('pat' => 'addrow', 'ver' => 2018060601, 'alt' => 'rowadd'),
array('pat' => 'texdecorate', 'ver' => 2018080600),
array('pat' => 'logbase', 'ver' => 2019031300, 'alt' => 'lg')
);
foreach ($patterns as $checkpat) {
if ($stackversion < $checkpat['ver']) {
foreach ($qfields as $field) {
if (strstr($this->$field ?? '', $checkpat['pat'])) {
$a = array('pat' => $checkpat['pat'], 'ver' => $checkpat['ver'], 'qfield' => stack_string($field));
$err = stack_string('stackversionerror', $a);
if (array_key_exists('alt', $checkpat)) {
$err .= ' ' . stack_string('stackversionerroralt', $checkpat['alt']);
}
$errors[] = $err;
}
// Look inside the PRT feedback variables. Should probably check the feedback as well.
foreach ($this->prts as $name => $prt) {
$kv = $prt->get_feedbackvariables_keyvals();
if (strstr($kv, $checkpat['pat'])) {
$a = array('pat' => $checkpat['pat'], 'ver' => $checkpat['ver'],
'qfield' => stack_string('feedbackvariables') . ' (' . $name . ')');
$err = stack_string('stackversionerror', $a);
if (array_key_exists('alt', $checkpat)) {
$err .= ' ' . stack_string('stackversionerroralt', $checkpat['alt']);
}
$errors[] = $err;
}
// Mul is no longer supported.
// We don't need to include a date check here because it is not a change in behaviour.
foreach ($this->inputs as $inputname => $input) {
Chris Sangwin
committed
if (!preg_match('/^([a-zA-Z]+|[a-zA-Z]+[0-9a-zA-Z_]*[0-9a-zA-Z]+)$/', $inputname)) {
$errors[] = stack_string('inputnameform', $inputname);
}
if (trim($options ?? '') !== '') {
$options = explode(',', $options);
foreach ($options as $opt) {
$opt = strtolower(trim($opt));
if ($opt === 'mul') {
$errors[] = stack_string('stackversionmulerror');
}
}
}
}
// Look for RexExp answer test which is no longer supported.
foreach ($this->prts as $name => $prt) {
if (array_key_exists('RegExp', $prt->get_answertests())) {
$errors[] = stack_string('stackversionregexp');
}
}
Chris Sangwin
committed
// Check files use match the files in the question.
$fs = get_file_storage();
$pat = '/@@PLUGINFILE@@([^@"])*[\'"]/';
Chris Sangwin
committed
$fields = array('questiontext', 'specificfeedback', 'generalfeedback', 'questiondescription');
Chris Sangwin
committed
foreach ($fields as $field) {
$text = $this->$field;
$filesexpected = preg_match($pat, $text ?? '');
Chris Sangwin
committed
$filesfound = $fs->get_area_files($context->id, 'question', $field, $this->id);
if (!$filesexpected && $filesfound != array()) {
$errors[] = stack_string('stackfileuseerror', stack_string($field));
}
}
// Add in any warnings.
$errors = array_merge($errors, $this->validate_warnings(true));
/*
* Unfortunately, "errors" stop a question being saved. So, we have a parallel warning mechanism.
* Warnings need to be addressed but should not stop a question being saved.
*/
public function validate_warnings($errors = false) {
$warnings = array();
// 1. Answer tests which require raw inputs actually have SAns a calculated value.
Chris Sangwin
committed
foreach ($this->prts as $prt) {
foreach ($prt->get_raw_sans_used() as $key => $sans) {
if (!array_key_exists(trim($sans), $this->inputs)) {
$warnings[] = stack_string_error('AT_raw_sans_needed', array('prt' => $key));
Chris Sangwin
committed
}
}
Chris Sangwin
committed
foreach ($prt->get_raw_arguments_used() as $name => $ans) {
$tvalue = trim($ans);
Chris Sangwin
committed
if ($tvalue === ';') {
$warnings[] = stack_string('nosemicolon') . ':' . $name;
}
}
Chris Sangwin
committed
}
// 2. Check alt-text exists.
// Reminder: previous approach in Oct 2021 tried to use libxml_use_internal_errors, but this was a dead end.
$tocheck = array();
$text = '';
if ($this->questiontextinstantiated !== null) {
$text = trim($this->questiontextinstantiated->get_rendered());
}
if ($text !== '') {
$tocheck[stack_string('questiontext')] = $text;
}
$ct = $this->get_generalfeedback_castext();
$text = trim($ct->get_rendered($this->castextprocessor));
if ($text !== '') {
$tocheck[stack_string('generalfeedback')] = $text;
// This is a compromise. We concatinate all nodes and we don't instantiate this!
foreach ($this->prts as $prt) {
$text = trim($prt->get_feedback_test());
if ($text !== '') {
$tocheck[$prt->get_name()] = $text;
}
}
foreach ($tocheck as $field => $text) {
// Replace unprotected & symbols, which happens a lot inside LaTeX equations.
$text = preg_replace("/&(?!\S+;)/", "&", $text);
$missingalt = stack_utils::count_missing_alttext($text);
if ($missingalt > 0) {
$warnings[] = stack_string_error('alttextmissing', array('field' => $field, 'num' => $missingalt));
}
}
// 3. Check for todo blocks.
$tocheck = array();
$fields = array('questiontext', 'specificfeedback', 'generalfeedback', 'questiondescription');
foreach ($fields as $field) {
$tocheck[stack_string($field)] = $this->$field;
}
foreach ($this->prts as $prt) {
$text = trim($prt->get_feedback_test());
if ($text !== '') {
$tocheck[$prt->get_name()] = $text;
}
}
$pat = '/\[\[todo/';
foreach ($tocheck as $field => $text) {
if (preg_match($pat, $text ?? '')) {
$warnings[] = stack_string_error('todowarning', array('field' => $field));
}
}
// 4. Language warning checks.
// Put language warning checks last (see guard clause below).
// Check multi-language versions all have the same languages.
$ml = new stack_multilang();
$qlangs = $ml->languages_used($this->questiontext);
asort($qlangs);
if ($qlangs != array() && !$errors) {
$warnings['questiontext'] = stack_string('questiontextlanguages', implode(', ', $qlangs));
}
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
// Language tags don't exist.
if ($qlangs == array()) {
return $warnings;
}
$problems = false;
$missinglang = array();
$extralang = array();
$fields = array('specificfeedback', 'generalfeedback');
foreach ($fields as $field) {
$text = $this->$field;
// Strip out feedback tags (to help non-trivial content check)..
foreach ($this->prts as $prt) {
$text = str_replace('[[feedback:' . $prt->get_name() . ']]', '', $text);
}
if ($ml->non_trivial_content_for_check($text)) {
$langs = $ml->languages_used($text);
foreach ($qlangs as $expectedlang) {
if (!in_array($expectedlang, $langs)) {
$problems = true;
$missinglang[$expectedlang][] = stack_string($field);
}
}
foreach ($langs as $lang) {
if (!in_array($lang, $qlangs)) {
$problems = true;
$extralang[stack_string($field)][] = $lang;
}
}
}
}
foreach ($this->prts as $prt) {
foreach ($prt->get_feedback_languages() as $nodes) {
// The nodekey is really the answernote from one branch of the node.
Matti Harjula
committed
// No actually it is not in the new PRT-system, it's just 'true' or 'false'.
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
foreach ($nodes as $nodekey => $langs) {
foreach ($qlangs as $expectedlang) {
if (!in_array($expectedlang, $langs)) {
$problems = true;
$missinglang[$expectedlang][] = $nodekey;
}
}
foreach ($langs as $lang) {
if (!in_array($lang, $qlangs)) {
$problems = true;
$extralang[$nodekey][] = $lang;
}
}
}
}
}
if ($problems) {
$warnings[] = stack_string_error('languageproblemsexist');
}
foreach ($missinglang as $lang => $missing) {
$warnings[] = stack_string('languageproblemsmissing',
array('lang' => $lang, 'missing' => implode(', ', $missing)));
}
foreach ($extralang as $field => $langs) {
$warnings[] = stack_string('languageproblemsextra',
array('field' => $field, 'langs' => implode(', ', $langs)));
}
Chris Sangwin
committed
/**
* Cache management.
*
* Returns named items from the cache and rebuilds it if the cache
* has been cleared.
*/
public function get_cached(string $key) {
global $DB;
if ($this->compiledcache !== null && isset($this->compiledcache['FAIL'])) {
// This question failed compilation, no need to try again in this request.
// Make sure the error is back in the error list.
$this->runtimeerrors[$this->compiledcache['FAIL']] = true;
return null;
}
// Do we have that particular thing in the cache?
Chris Sangwin
committed
if ($this->compiledcache === null || !array_key_exists($key, $this->compiledcache)) {
// If not do the compilation.
try {
$this->compiledcache = self::compile($this->id,
$this->questionvariables, $this->inputs, $this->prts,
Matti Harjula
committed
$this->questiontextformat,
$this->questionnote,
$this->generalfeedback, $this->generalfeedbackformat,
$this->specificfeedback, $this->specificfeedbackformat,
$this->questiondescription, $this->questiondescriptionformat,
Matti Harjula
committed
$this->prtcorrect, $this->prtcorrectformat,
$this->prtpartiallycorrect, $this->prtpartiallycorrectformat,
$this->prtincorrect, $this->prtincorrectformat, $this->penalty);
// Invalidate Moodle question-cache and add there.
if (is_integer($this->id) || is_numeric($this->id)) {
// Save to DB. If the question is there.
// Could not be in some API situations.
$sql = 'UPDATE {qtype_stack_options} SET compiledcache = ? WHERE questionid = ?';
$params[] = json_encode($this->compiledcache);
$params[] = $this->id;
$DB->execute($sql, $params);
// Invalidate the question definition cache.
// First from the next sessions.
// TODO: what exactly do we use here as the key
// and what sort of errors does the compilation generate.
// CHRIS: The compilation generates errors that relate to the static validation of
// the question, any such errors are fatal and will be apparent on the first opening
// of the question in bulk tests or elsewhere, silencing them makes no sense.
// These are not runtime errors they are validation errors for materials that should
// not have managed to get through the editor.
$this->runtimeerrors[$e->getMessage()] = true;
$this->compiledcache = ['FAIL' => $e->getMessage()];
}
}
Chris Sangwin
committed
// A runtime error means we don't have the $key in the cache.
Chris Sangwin
committed
// We don't want an error here, we want to degrade gracefully.
$ret = null;
if (is_array($this->compiledcache) && array_key_exists($key, $this->compiledcache)) {
$ret = $this->compiledcache[$key];
}
return $ret;
/**
* Helper method for "compiling" a question, validates and finds all the things
* that do not change unless the question changes and stores them in a dictionary.
*
* Note that does throw exceptions about validation details.
*
* Currently the cache contains the following keys:
* 'units' for declaring the units-mode.
* 'forbiddenkeys' for the lsit of those.
* 'contextvariables-qv' the pre-validated question-variables which are context variables.
* 'statement-qv' the pre-validated question-variables.
* 'preamble-qv' the matching blockexternals.
* 'required' the lists of inputs required by given PRTs an array by PRT-name.
* 'castext-qt' for the question-text as compiled CASText2.
* 'castext-qn' for the question-note as compiled CASText2.
* 'castext-...' for the model-solution and prtpartiallycorrect etc.
* 'castext-td-...' for downloadable generated text content.
Matti Harjula
committed
* 'security-context' mainly lists keys that are student inputs.
* 'prt-*' the compiled PRT-logics in an array. Divided by usage.
Matti Harjula
committed
* 'langs' a list of language codes used in this question.
*
* In the future expect the following:
* 'security-config' extended logic for cas-security, e.g. custom-units.
*
* @param int the identifier of this question fot use if we have pluginfiles
* @param string the questionvariables
* @param array inputs as objects, keyed by input name
* @param array PRTs as objects
* @param stack_options the options in use, if they would ever matter
* @param string question-text
* @param string question-text format
* @param string question-note
* @param string general-feedback
* @param string general-feedback format...
* @param defaultpenalty
* @return array a dictionary of things that might be expensive to generate.
*/
public static function compile($id, $questionvariables, $inputs, $prts, $options,
$questiontext, $questiontextformat,
$questionnote,
$generalfeedback, $generalfeedbackformat,
$specificfeedback, $specificfeedbackformat,
$questiondescription, $questiondescriptionformat,
$prtcorrect, $prtcorrectformat,
$prtpartiallycorrect, $prtpartiallycorrectformat,
$prtincorrect, $prtincorrectformat, $defaultpenalty) {
// NOTE! We do not compile during question save as that would make
// import actions slow. We could compile during fromform-validation
// but we really should look at refactoring that to better interleave
// the compilation.
//
// As we currently compile at the first use things start slower than they could.
// The cache will be a dictionary with many things.
$cc = [];
// Some details are globals built from many sources.
$units = false;
$forbiddenkeys = [];
Matti Harjula
committed
// Some counter resets to ensure that the result is the same even if
// we for some reason would compile twice in a session.
// Happens during first preview and can lead to cache being always out
// of sync if textdownload is in play.
stack_cas_castext2_textdownload::$countfiles = 1;
// Static string extrraction now for CASText2 in top level text blobs and PRTs,
// question varaibles and in the future probably also from input2.
$map = new castext2_static_replacer([]);
// First handle the question variables.
if ($questionvariables === null || trim($questionvariables) === '') {
$cc['statement-qv'] = null;
$cc['preamble-qv'] = null;
$cc['contextvariables-qv'] = null;
$cc['security-context'] = [];
} else {
$kv = new stack_cas_keyval($questionvariables, $options);
if (!$kv->get_valid()) {
throw new stack_exception('Error(s) in question-variables: ' . implode('; ', $kv->get_errors()));
}
$c = $kv->compile('/qv', $map);
// Store the pre-validated statement representing the whole qv.
$cc['statement-qv'] = $c['statement'];
// Store any contextvariables, e.g. assume statements.
$cc['contextvariables-qv'] = $c['contextvariables'];
// Store the possible block external features.
$cc['preamble-qv'] = $c['blockexternal'];
// Finally extend the forbidden keys set if we saw any variables written.
if (isset($c['references']['write'])) {
$forbiddenkeys = array_merge($forbiddenkeys, $c['references']['write']);
}
Matti Harjula
committed
if (isset($c['includes'])) {
$cc['includes']['keyval'] = $c['includes'];
}
// Collect the language codes in use. For our purposes the question-text
Matti Harjula
committed
// is all that is needed. Other places may have other values but these are
// enough after all the validations have passed.
$ml = new stack_multilang();
$cc['langs'] = $ml->languages_used($questiontext);
// Then do some basic detail collection related to the inputs and PRTs.
foreach ($inputs as $input) {
if (is_a($input, 'stack_units_input')) {
$units = true;
break;
}
}
$cc['required'] = [];
$cc['prt-preamble'] = [];
$cc['prt-contextvariables'] = [];
$cc['prt-signature'] = [];
$cc['prt-definition'] = [];
Matti Harjula
committed
$i = 0;
Matti Harjula
committed
$path = '/p/' . $i;
$i = $i + 1;
$r = $prt->compile($inputs, $forbiddenkeys, $defaultpenalty, $sec, $path, $map);
$cc['required'][$name] = $r['required'];
if ($r['be'] !== null && $r['be'] !== '') {
$cc['prt-preamble'][$name] = $r['be'];
if ($r['cv'] !== null && $r['cv'] !== '') {
$cc['prt-contextvariables'][$name] = $r['cv'];
$cc['prt-signature'][$name] = $r['sig'];
$cc['prt-definition'][$name] = $r['def'];
$cc['prt-trace'][$name] = $r['trace'];
Matti Harjula
committed
if (isset($r['includes'])) {
if (!isset($cc['includes'])) {
$cc['includes'] = $r['includes'];
} else {
if (isset($r['includes']['keyval'])) {
if (!isset($cc['includes']['keyval'])) {
$cc['includes']['keyval'] = [];
}
$cc['includes']['keyval'] = array_unique(array_merge($cc['includes']['keyval'],
$r['includes']['keyval']));
Matti Harjula
committed
}
if (isset($r['includes']['castext'])) {
if (!isset($cc['includes']['castext'])) {
$cc['includes']['castext'] = [];
}
$cc['includes']['castext'] = array_unique(array_merge($cc['includes']['castext'],
$r['includes']['castext']));
Matti Harjula
committed
}
}
}
}
// Note that instead of just adding the unit loading to the 'preamble-qv'
// and forgetting about units we do keep this bit of information stored
// as it may be used in input configuration at some later time.
$cc['units'] = $units;
$cc['forbiddenkeys'] = $forbiddenkeys;
// Do some pluginfile mapping. Note that the PRT-nodes are mapped in PRT-compiler.
Matti Harjula
committed
$questiontext = stack_castext_file_filter($questiontext, [
'questionid' => $id,
'field' => 'questiontext'
]);
$generalfeedback = stack_castext_file_filter($generalfeedback, [
'questionid' => $id,
'field' => 'generalfeedback'
]);
$specificfeedback = stack_castext_file_filter($specificfeedback, [
'questionid' => $id,
'field' => 'specificfeedback'
]);
// Legacy questions may have a null description before being saved/compiled.
if ($questiondescription === null) {
$questiondescription = '';
}
$questiondescription = stack_castext_file_filter($questiondescription, [
'questionid' => $id,
'field' => 'questiondescription'
]);
Matti Harjula
committed
$prtcorrect = stack_castext_file_filter($prtcorrect, [
'questionid' => $id,
'field' => 'prtcorrect'
]);
$prtpartiallycorrect = stack_castext_file_filter($prtpartiallycorrect, [
'questionid' => $id,
'field' => 'prtpartiallycorrect'
]);
$prtincorrect = stack_castext_file_filter($prtincorrect, [
'questionid' => $id,
'field' => 'prtincorrect'
]);
// Compile the castext fragments.
$ctoptions = [
'prt-names' => array_flip(array_keys($prts)),
'io-blocks-as-raw' => 'pre-input2',
'static string extractor' => $map
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($questiontext, '/qt');
if (!$ct->get_valid($questiontextformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in question-text: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-qt'] = $ct->get_evaluationform();
// Note that only with "question-text" may we get inlined downloads.
foreach ($ct->get_special_content() as $key => $values) {
if ($key === 'text-download') {
foreach ($values as $k => $v) {
$cc['castext-td-' . $k] = $v;
}
Matti Harjula
committed
} else if ($key === 'castext-includes') {
if (!isset($cc['includes'])) {
$cc['includes'] = ['castext' => $values];
} else if (!isset($cc['includes']['castext'])) {
$cc['includes']['castext'] = $values;
} else {
foreach ($values as $url) {
if (array_search($url, $cc['includes']['castext']) === false) {
$cc['includes']['castext'][] = $url;
}
}
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($questionnote, '/qn');
if (!$ct->get_valid(FORMAT_HTML, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in question-note: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-qn'] = $ct->get_evaluationform();
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($generalfeedback, '/gf');
if (!$ct->get_valid($generalfeedbackformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in general-feedback: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-gf'] = $ct->get_evaluationform();
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($specificfeedback, '/sf');
if (!$ct->get_valid($specificfeedbackformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in specific-feedback: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-sf'] = $ct->get_evaluationform();
}
$ct = castext2_evaluatable::make_from_source($questiondescription, '/qd');
if (!$ct->get_valid($questiondescriptionformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in question description: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-qd'] = $ct->get_evaluationform();
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($prtcorrect, '/pc');
if (!$ct->get_valid($prtcorrectformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in PRT-correct message: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-prt-c'] = $ct->get_evaluationform();
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($prtpartiallycorrect, '/pp');
if (!$ct->get_valid($prtpartiallycorrectformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in PRT-partially correct message: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-prt-pc'] = $ct->get_evaluationform();
}
Matti Harjula
committed
$ct = castext2_evaluatable::make_from_source($prtincorrect, '/pi');
if (!$ct->get_valid($prtincorrectformat, $ctoptions, $sec)) {
throw new stack_exception('Error(s) in PRT-incorrect message: ' . implode('; ', $ct->get_errors(false)));
} else {
$cc['castext-prt-ic'] = $ct->get_evaluationform();
}
// Remember to collect the extracted strings once all has been done.
$cc['static-castext-strings'] = $map->get_map();
// The time of the security context as it were during 2021 was short, now only
Matti Harjula
committed
// the input variables remain.
$si = [];
// Mark all inputs. To let us know that they have special types.
foreach ($inputs as $key => $value) {
if (!isset($si[$key])) {
$si[$key] = [];
}
$si[$key][-2] = -2;
}
$cc['security-context'] = $si;
/**
* Moodle specific acessor for question capabilities.
*/
public function has_cap(string $capname): bool {
return $this->has_question_capability($capname);
}