protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$this->initialise_question_answers($question, $questiondata);
$this->initialise_combined_feedback($question, $questiondata);
$question->places = array();
$counter = 1;
foreach ($questiondata->options->answers as $choicedata) {
/* fraction contains a 1 */
if (strpos($choicedata->fraction, '1') !== false) {
$question->places[$counter] = $choicedata->answer;
$counter++;
}
}
/* Will put empty places '' where there is no text content.
* l for left delimiter r for right delimiter
*/
$l = substr($question->delimitchars, 0, 1);
$r = substr($question->delimitchars, 1, 1);
$nonfieldregex = '/\\' . $l . '.*?\\' . $r . '/';
$bits = preg_split($nonfieldregex, $question->questiontext, null, PREG_SPLIT_DELIM_CAPTURE);
$question->textfragments[0] = array_shift($bits);
$i = 1;
while (!empty($bits)) {
$question->textfragments[$i] = array_shift($bits);
$i += 1;
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->shufflechoices = $questiondata->options->shuffleanswers;
$this->initialise_combined_feedback($question, $questiondata, true);
$question->choices = array();
$choiceindexmap = array();
// Store the choices in arrays by group.
foreach ($questiondata->options->drags as $dragdata) {
$choice = $this->make_choice($dragdata);
if (array_key_exists($choice->choice_group(), $question->choices)) {
$question->choices[$choice->choice_group()][$dragdata->no] = $choice;
} else {
$question->choices[$choice->choice_group()][1] = $choice;
}
end($question->choices[$choice->choice_group()]);
$choiceindexmap[$dragdata->no] = array($choice->choice_group(), key($question->choices[$choice->choice_group()]));
}
$question->places = array();
$question->rightchoices = array();
$i = 1;
foreach ($questiondata->options->drops as $dropdata) {
list($group, $choiceindex) = $choiceindexmap[$dropdata->choice];
$dropdata->group = $group;
$question->places[$dropdata->no] = $this->make_place($dropdata);
$question->rightchoices[$dropdata->no] = $choiceindex;
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->shufflechoices = $questiondata->options->shuffleanswers;
$this->initialise_combined_feedback($question, $questiondata, true);
$question->choices = array();
$choiceindexmap = array();
// Store the choices in arrays by group.
// This code is weird. The first choice in each group gets key 1 in the
// $question->choices[$choice->choice_group()] array, and the others get
// key $choice->no. Therefore you need to think carefully whether you
// are using the key, or $choice->no. This is presumably a mistake, but
// one that is now essentially un-fixable, since many questions of this
// type have been attempted, and theys keys get stored in the attempt data.
foreach ($questiondata->options->drags as $dragdata) {
$choice = $this->make_choice($dragdata);
if (array_key_exists($choice->choice_group(), $question->choices)) {
$question->choices[$choice->choice_group()][$dragdata->no] = $choice;
} else {
$question->choices[$choice->choice_group()][1] = $choice;
}
end($question->choices[$choice->choice_group()]);
$choiceindexmap[$dragdata->no] = array($choice->choice_group(), key($question->choices[$choice->choice_group()]));
}
$question->places = array();
$question->rightchoices = array();
$i = 1;
foreach ($questiondata->options->drops as $dropdata) {
list($group, $choiceindex) = $choiceindexmap[$dropdata->choice];
$dropdata->group = $group;
$question->places[$dropdata->no] = $this->make_place($dropdata);
$question->rightchoices[$dropdata->no] = $choiceindex;
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->responseformat = $questiondata->options->responseformat;
$question->graderinfo = $questiondata->options->graderinfo;
$question->graderinfoformat = $questiondata->options->graderinfoformat;
}
protected function initialise_question_instance(question_definition $question, $questiondata) {
parent::initialise_question_instance($question, $questiondata);
$question->responseformat = $questiondata->options->responseformat;
$question->responsefieldlines = $questiondata->options->responsefieldlines;
$question->attachments = $questiondata->options->attachments;
$question->graderinfo = $questiondata->options->graderinfo;
$question->graderinfoformat = $questiondata->options->graderinfoformat;
$question->responselimitpolicy = $questiondata->options->responselimitpolicy;
$question->wordlimit = $questiondata->options->wordlimit;
$question->charlimit = $questiondata->options->charlimit;
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->responseformat = $questiondata->options->responseformat;
$question->responsefieldlines = $questiondata->options->responsefieldlines;
$question->attachments = $questiondata->options->attachments;
$question->graderinfo = $questiondata->options->graderinfo;
$question->graderinfoformat = $questiondata->options->graderinfoformat;
$question->responsetemplate = $questiondata->options->responsetemplate;
$question->responsetemplateformat = $questiondata->options->responsetemplateformat;
}
/**
* Initialise the common question_definition fields.
*
* @param question_definition $question the question_definition we are creating.
* @param object $questiondata the question data loaded from the database.
*/
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->rows = $questiondata->options->rows;
$question->cols = $questiondata->options->cols;
$question->weights = $questiondata->options->weights;
$question->grademethod = $questiondata->options->grademethod;
$question->multiple = $questiondata->options->multiple;
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$availablesaquestions = $this->get_available_saquestions_from_category($question->category, $questiondata->options->subcats);
$question->shufflestems = false;
$question->stems = array();
$question->choices = array();
$question->right = array();
$this->initialise_combined_feedback($question, $questiondata);
$question->questionsloader = new qtype_randomsamatch_question_loader($availablesaquestions, $questiondata->options->choose);
}
protected function initialise_question_instance(question_definition $question, $questiondata) {
parent::initialise_question_instance($question, $questiondata);
$question->shufflestems = $questiondata->options->shuffleanswers;
$this->initialise_combined_feedback($question, $questiondata, true);
$question->stems = array();
$question->choices = array();
$question->right = array();
foreach ($questiondata->options->subquestions as $matchsub) {
$ans = $matchsub->answertext;
$key = array_search($matchsub->answertext, $question->choices);
if ($key === false) {
$key = $matchsub->id;
$question->choices[$key] = $matchsub->answertext;
}
if ($matchsub->questiontext !== '') {
$question->stems[$matchsub->id] = $matchsub->questiontext;
$question->stemformat[$matchsub->id] = $matchsub->questiontextformat;
$question->right[$matchsub->id] = $key;
}
}
}
protected function initialise_question_instance(question_definition $question, $questiondata) {
question_type::initialise_question_instance($question, $questiondata);
$question->shuffleanswers = $questiondata->options->shuffleanswers;
$question->answernumbering = $questiondata->options->answernumbering;
if (!empty($questiondata->options->layout)) {
$question->layout = $questiondata->options->layout;
} else {
$question->layout = qtype_multichoice_single_question::LAYOUT_VERTICAL;
}
$question->synchronised = $questiondata->options->synchronize;
$this->initialise_combined_feedback($question, $questiondata, true);
$this->initialise_question_answers($question, $questiondata);
foreach ($questiondata->options->answers as $a) {
$question->answers[$a->id]->correctanswerlength = $a->correctanswerlength;
$question->answers[$a->id]->correctanswerformat = $a->correctanswerformat;
}
$question->datasetloader = new qtype_calculated_dataset_loader($questiondata->id);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->shuffleanswers = $questiondata->options->shuffleanswers;
$question->answernumbering = $questiondata->options->answernumbering;
if (!empty($questiondata->options->layout)) {
$question->layout = $questiondata->options->layout;
} else {
$question->layout = qtype_multichoice_single_question::LAYOUT_VERTICAL;
}
$question->correctfeedback = $questiondata->options->correctfeedback;
$question->correctfeedbackformat = $questiondata->options->correctfeedbackformat;
$question->incorrectfeedback = $questiondata->options->incorrectfeedback;
$question->incorrectfeedbackformat = $questiondata->options->incorrectfeedbackformat;
$question->shownumcorrect = $questiondata->options->shownumcorrect;
$this->initialise_question_answers($question, $questiondata, false);
}
protected function initialise_question_instance(question_definition $question, $questiondata) {
parent::initialise_question_instance($question, $questiondata);
$this->initialise_numerical_answers($question, $questiondata);
$question->unitdisplay = $questiondata->options->showunits;
$question->unitgradingtype = $questiondata->options->unitgradingtype;
$question->unitpenalty = $questiondata->options->unitpenalty;
$question->ap = $this->make_answer_processor($questiondata->options->units,
$questiondata->options->unitsleft);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
// TODO.
parent::initialise_question_instance($question, $questiondata);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->usecase = $questiondata->options->usecase;
$question->usehint = $questiondata->options->usehint;
$question->studentshowalternate = $questiondata->options->studentshowalternate;
$this->initialise_question_answers($question, $questiondata);
$qid = $question->id;
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
global $DB;
$answers = $questiondata->options->answers;
$question->generalfeedback = $answers[$questiondata->options->answer]->feedback;
$question->generalfeedbackformat = $answers[$questiondata->options->answer]->feedbackformat;
$question->answerid = $questiondata->options->answer;
//$question->rightanswer = 10;
$getanswers = $DB->get_records('question_answers', array('question' => $question->id), 'id ASC');
$answerval = array_shift($getanswers);
if ($answerval) {
$question->rightanswer = $answerval->answer;
}
$getanswers = $DB->get_records('question_classdiagram', array('question' => $question->id), 'id ASC');
$answerval = array_shift($getanswers);
if ($answerval) {
$question->class_marks = $answerval->class_marks;
$question->class_name_marks = $answerval->class_name_marks;
$question->class_attribute_marks = $answerval->class_attribute_marks;
$question->class_extra_marks = $answerval->class_extra_marks;
$question->association_marks = $answerval->association_marks;
$question->association_type_marks = $answerval->association_type_marks;
$question->association_cardinality_marks = $answerval->association_cardinality_marks;
$question->association_extra_marks = $answerval->association_extra_marks;
$question->generalization_marks = $answerval->generalization_marks;
$question->generalization_type_marks = $answerval->generalization_type_marks;
$question->generalization_extra_marks = $answerval->generalization_extra_marks;
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$this->initialise_question_answers($question, $questiondata);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->shuffleanswers = $questiondata->options->shuffleanswers;
$question->qdifficulty = $questiondata->options->qdifficulty;
if (!empty($questiondata->options->layout)) {
$question->layout = $questiondata->options->layout;
} else {
$question->layout = qtype_turmultiplechoice_single_question::LAYOUT_VERTICAL;
}
$this->initialise_combined_feedback($question, $questiondata, true);
$this->initialise_question_answers($question, $questiondata, false);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$answers = $questiondata->options->answers;
if ($answers[$questiondata->options->trueanswer]->fraction > 0.99) {
$question->rightanswer = true;
} else {
$question->rightanswer = false;
}
$question->truefeedback = $answers[$questiondata->options->trueanswer]->feedback;
$question->falsefeedback = $answers[$questiondata->options->falseanswer]->feedback;
$question->truefeedbackformat = $answers[$questiondata->options->trueanswer]->feedbackformat;
$question->falsefeedbackformat = $answers[$questiondata->options->falseanswer]->feedbackformat;
$question->trueanswerid = $questiondata->options->trueanswer;
$question->falseanswerid = $questiondata->options->falseanswer;
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
foreach ($questiondata->options as $field => $value) {
if (!isset($question->{$field})) {
$question->{$field} = $value;
}
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->shufflechoices = $questiondata->options->shuffleanswers;
$this->initialise_combined_feedback($question, $questiondata, true);
$question->choices = array();
$choiceindexmap = array();
// Store the choices in arrays by group.
$i = 1;
foreach ($questiondata->options->answers as $choicedata) {
$choice = $this->make_choice($choicedata);
if (array_key_exists($choice->choice_group(), $question->choices)) {
$question->choices[$choice->choice_group()][] = $choice;
} else {
$question->choices[$choice->choice_group()][1] = $choice;
}
end($question->choices[$choice->choice_group()]);
$choiceindexmap[$i] = array($choice->choice_group(), key($question->choices[$choice->choice_group()]));
$i += 1;
}
$question->places = array();
$question->textfragments = array();
$question->rightchoices = array();
// Break up the question text, and store the fragments, places and right answers.
$bits = preg_split('/\\[\\[(\\d+)]]/', $question->questiontext, null, PREG_SPLIT_DELIM_CAPTURE);
$question->textfragments[0] = array_shift($bits);
$i = 1;
while (!empty($bits)) {
$choice = array_shift($bits);
list($group, $choiceindex) = $choiceindexmap[$choice];
$question->places[$i] = $group;
$question->rightchoices[$i] = $choiceindex;
$question->textfragments[$i] = array_shift($bits);
$i += 1;
}
}
protected function initialise_question_instance($question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$bits = preg_split('/\\{#(\\d+)\\}/', $question->questiontext, null, PREG_SPLIT_DELIM_CAPTURE);
$question->textfragments[0] = array_shift($bits);
$i = 1;
while (!empty($bits)) {
$question->places[$i] = array_shift($bits);
$question->textfragments[$i] = array_shift($bits);
$i += 1;
}
foreach ($questiondata->options->questions as $key => $subqdata) {
$subqdata->contextid = $questiondata->contextid;
$question->subquestions[$key] = question_bank::make_question($subqdata);
$question->subquestions[$key]->maxmark = $subqdata->defaultmark;
if (isset($subqdata->options->layout)) {
$question->subquestions[$key]->layout = $subqdata->options->layout;
}
}
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$this->initialise_ordering_feedback($question, $questiondata);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->responseformat = $questiondata->options->responseformat;
$question->graderinfo = $questiondata->options->graderinfo;
$question->graderinfoformat = $questiondata->options->graderinfoformat;
$question->backimage = $questiondata->options->backimage;
$question->boardsize = $questiondata->options->boardsize;
$question->timelimit = $questiondata->options->timelimit;
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
question_bank::get_qtype('numerical')->initialise_numerical_answers($question, $questiondata);
foreach ($questiondata->options->answers as $a) {
$question->answers[$a->id]->tolerancetype = $a->tolerancetype;
$question->answers[$a->id]->correctanswerlength = $a->correctanswerlength;
$question->answers[$a->id]->correctanswerformat = $a->correctanswerformat;
}
$question->synchronised = $questiondata->options->synchronize;
$question->unitdisplay = $questiondata->options->showunits;
$question->unitgradingtype = $questiondata->options->unitgradingtype;
$question->unitpenalty = $questiondata->options->unitpenalty;
$question->ap = question_bank::get_qtype('numerical')->make_answer_processor($questiondata->options->units, $questiondata->options->unitsleft);
$question->datasetloader = new qtype_calculated_dataset_loader($questiondata->id);
}
protected function initialise_question_instance(question_definition $question, $questiondata)
{
parent::initialise_question_instance($question, $questiondata);
$question->questionvariables = $questiondata->options->questionvariables;
$question->questionnote = $questiondata->options->questionnote;
$question->specificfeedback = $questiondata->options->specificfeedback;
$question->specificfeedbackformat = $questiondata->options->specificfeedbackformat;
$question->prtcorrect = $questiondata->options->prtcorrect;
$question->prtcorrectformat = $questiondata->options->prtcorrectformat;
$question->prtpartiallycorrect = $questiondata->options->prtpartiallycorrect;
$question->prtpartiallycorrectformat = $questiondata->options->prtpartiallycorrectformat;
$question->prtincorrect = $questiondata->options->prtincorrect;
$question->prtincorrectformat = $questiondata->options->prtincorrectformat;
$question->variantsselectionseed = $questiondata->options->variantsselectionseed;
$question->options = new stack_options();
$question->options->set_option('multiplicationsign', $questiondata->options->multiplicationsign);
$question->options->set_option('complexno', $questiondata->options->complexno);
$question->options->set_option('inversetrig', $questiondata->options->inversetrig);
$question->options->set_option('matrixparens', $questiondata->options->matrixparens);
$question->options->set_option('sqrtsign', (bool) $questiondata->options->sqrtsign);
$question->options->set_option('simplify', (bool) $questiondata->options->questionsimplify);
$question->options->set_option('assumepos', (bool) $questiondata->options->assumepositive);
$requiredparams = stack_input_factory::get_parameters_used();
foreach ($questiondata->inputs as $name => $inputdata) {
$allparameters = array('boxWidth' => $inputdata->boxsize, 'strictSyntax' => (bool) $inputdata->strictsyntax, 'insertStars' => (int) $inputdata->insertstars, 'syntaxHint' => $inputdata->syntaxhint, 'forbidWords' => $inputdata->forbidwords, 'allowWords' => $inputdata->allowwords, 'forbidFloats' => (bool) $inputdata->forbidfloat, 'lowestTerms' => (bool) $inputdata->requirelowestterms, 'sameType' => (bool) $inputdata->checkanswertype, 'mustVerify' => (bool) $inputdata->mustverify, 'showValidation' => $inputdata->showvalidation);
$parameters = array();
foreach ($requiredparams[$inputdata->type] as $paramname) {
if ($paramname == 'inputType') {
continue;
}
$parameters[$paramname] = $allparameters[$paramname];
}
// TODO: Do something with $inputdata->options here.
$question->inputs[$name] = stack_input_factory::make($inputdata->type, $inputdata->name, $inputdata->tans, $parameters);
}
$totalvalue = 0;
foreach ($questiondata->prts as $name => $prtdata) {
$totalvalue += $prtdata->value;
}
if ($questiondata->prts && $totalvalue < 1.0E-7) {
throw new coding_exception('There is an error authoring your question. ' . 'The $totalvalue, the marks available for the question, must be positive in question ' . $question->name);
}
foreach ($questiondata->prts as $name => $prtdata) {
$nodes = array();
foreach ($prtdata->nodes as $nodedata) {
$sans = new stack_cas_casstring($nodedata->sans);
$sans->get_valid('t');
$tans = new stack_cas_casstring($nodedata->tans);
$tans->get_valid('t');
if (is_null($nodedata->falsepenalty) || $nodedata->falsepenalty === '') {
$falsepenalty = $questiondata->penalty;
} else {
$falsepenalty = $nodedata->falsepenalty;
}
if (is_null($nodedata->truepenalty) || $nodedata->truepenalty === '') {
$truepenalty = $questiondata->penalty;
} else {
$truepenalty = $nodedata->truepenalty;
}
$node = new stack_potentialresponse_node($sans, $tans, $nodedata->answertest, $nodedata->testoptions, (bool) $nodedata->quiet, '', $nodedata->id);
$node->add_branch(0, $nodedata->falsescoremode, $nodedata->falsescore, $falsepenalty, $nodedata->falsenextnode, $nodedata->falsefeedback, $nodedata->falsefeedbackformat, $nodedata->falseanswernote);
$node->add_branch(1, $nodedata->truescoremode, $nodedata->truescore, $truepenalty, $nodedata->truenextnode, $nodedata->truefeedback, $nodedata->truefeedbackformat, $nodedata->trueanswernote);
$nodes[$nodedata->nodename] = $node;
}
// TODO $feedbackvariables, and $sans, $tans, should probably still be strings
// here, and should be converted to CAS stuff later, only if needed.
if ($prtdata->feedbackvariables) {
$feedbackvariables = new stack_cas_keyval($prtdata->feedbackvariables, null, null, 't');
$feedbackvariables = $feedbackvariables->get_session();
} else {
$feedbackvariables = null;
}
$question->prts[$name] = new stack_potentialresponse_tree($name, '', (bool) $prtdata->autosimplify, $prtdata->value / $totalvalue, $feedbackvariables, $nodes, $prtdata->firstnodename);
}
$question->deployedseeds = array_values($questiondata->deployedseeds);
}
