mirror of
https://github.com/moodle/moodle.git
synced 2025-08-09 02:46:40 +02:00
1388 lines
59 KiB
PHP
Executable file
1388 lines
59 KiB
PHP
Executable file
<?php
|
|
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Moodle XML question importer.
|
|
*
|
|
* @package qformat
|
|
* @subpackage qformat_xml
|
|
* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
|
|
/**
|
|
* Importer for Moodle XML question format.
|
|
*
|
|
* See http://docs.moodle.org/en/Moodle_XML_format for a description of the format.
|
|
*
|
|
* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
require_once($CFG->libdir . '/xmlize.php');
|
|
|
|
class qformat_xml extends qformat_default {
|
|
|
|
function provide_import() {
|
|
return true;
|
|
}
|
|
|
|
function provide_export() {
|
|
return true;
|
|
}
|
|
|
|
// IMPORT FUNCTIONS START HERE
|
|
|
|
/**
|
|
* Translate human readable format name
|
|
* into internal Moodle code number
|
|
* @param string name format name from xml file
|
|
* @return int Moodle format code
|
|
*/
|
|
function trans_format( $name ) {
|
|
$name = trim($name);
|
|
|
|
if ($name=='moodle_auto_format') {
|
|
$id = 0;
|
|
}
|
|
elseif ($name=='html') {
|
|
$id = 1;
|
|
}
|
|
elseif ($name=='plain_text') {
|
|
$id = 2;
|
|
}
|
|
elseif ($name=='wiki_like') {
|
|
$id = 3;
|
|
}
|
|
elseif ($name=='markdown') {
|
|
$id = 4;
|
|
}
|
|
else {
|
|
$id = 0; // or maybe warning required
|
|
}
|
|
return $id;
|
|
}
|
|
|
|
/**
|
|
* Translate human readable single answer option
|
|
* to internal code number
|
|
* @param string name true/false
|
|
* @return int internal code number
|
|
*/
|
|
function trans_single( $name ) {
|
|
$name = trim($name);
|
|
if ($name == "false" || !$name) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* process text string from xml file
|
|
* @param array $text bit of xml tree after ['text']
|
|
* @return string processed text
|
|
*/
|
|
function import_text( $text ) {
|
|
// quick sanity check
|
|
if (empty($text)) {
|
|
return '';
|
|
}
|
|
$data = $text[0]['#'];
|
|
return trim($data);
|
|
}
|
|
|
|
/**
|
|
* return the value of a node, given a path to the node
|
|
* if it doesn't exist return the default value
|
|
* @param array xml data to read
|
|
* @param array path path to node expressed as array
|
|
* @param mixed default
|
|
* @param bool istext process as text
|
|
* @param string error if set value must exist, return false and issue message if not
|
|
* @return mixed value
|
|
*/
|
|
function getpath($xml, $path, $default, $istext=false, $error='') {
|
|
foreach ($path as $index) {
|
|
if (!isset($xml[$index])) {
|
|
if (!empty($error)) {
|
|
$this->error( $error );
|
|
return false;
|
|
} else {
|
|
return $default;
|
|
}
|
|
}
|
|
else $xml = $xml[$index];
|
|
}
|
|
if ($istext) {
|
|
if (!is_string($xml)) {
|
|
$this->error( get_string('invalidxml','qformat_xml') );
|
|
}
|
|
$xml = trim($xml);
|
|
}
|
|
|
|
return $xml;
|
|
}
|
|
|
|
|
|
/**
|
|
* import parts of question common to all types
|
|
* @param $question array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_headers($question) {
|
|
// get some error strings
|
|
$error_noname = get_string('xmlimportnoname','quiz');
|
|
$error_noquestion = get_string('xmlimportnoquestion','quiz');
|
|
|
|
// this routine initialises the question object
|
|
$qo = $this->defaultquestion();
|
|
|
|
// question name
|
|
$qo->name = $this->getpath( $question, array('#','name',0,'#','text',0,'#'), '', true, $error_noname );
|
|
$qo->questiontext = $this->getpath($question, array('#','questiontext',0,'#','text',0,'#'), '', true );
|
|
$qo->questiontextformat = $this->trans_format($this->getpath($question, array('#','questiontext',0,'@','format'), ''));
|
|
$qo->image = $this->getpath($question, array('#','image',0,'#'), $qo->image );
|
|
$image_base64 = $this->getpath( $question, array('#','image_base64','0','#'),'' );
|
|
if (!empty($image_base64)) {
|
|
$qo->image = $this->importimagefile($qo->image, $image_base64);
|
|
}
|
|
|
|
$qo->questiontextfiles = array();
|
|
|
|
// restore files in questiontext
|
|
$files = $this->getpath($question, array('#', 'questiontext', 0, '#','file'), array(), false);
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->questiontextfiles[] = $data;
|
|
}
|
|
|
|
// restore files in generalfeedback
|
|
$qo->generalfeedback = $this->getpath($question, array('#','generalfeedback',0,'#','text',0,'#'), $qo->generalfeedback, true);
|
|
$qo->generalfeedbackfiles = array();
|
|
$qo->generalfeedbackformat = $this->trans_format($this->getpath($question, array('#', 'generalfeedback', 0, '@', 'format'), ''));
|
|
$files = $this->getpath($question, array('#', 'generalfeedback', 0, '#', 'file'), array(), false);
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->generalfeedbackfiles[] = $data;
|
|
}
|
|
|
|
$qo->defaultgrade = $this->getpath( $question, array('#','defaultgrade',0,'#'), $qo->defaultgrade );
|
|
$qo->penalty = $this->getpath( $question, array('#','penalty',0,'#'), $qo->penalty );
|
|
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import the common parts of a single answer
|
|
* @param array answer xml tree for single answer
|
|
* @return object answer object
|
|
*/
|
|
function import_answer($answer) {
|
|
$fraction = $this->getpath($answer, array('@', 'fraction'), 0);
|
|
$answertext = $this->getpath($answer, array('#', 'text', 0, '#'), '', true);
|
|
$answerformat = $this->trans_format($this->getpath($answer, array('#', 'text', 0, '#'), ''));
|
|
$answerfiles = array();
|
|
$files = $this->getpath($answer, array('#', 'answer', 0, '#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->name = $file['@']['name'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$answerfiles[] = $data;
|
|
}
|
|
|
|
$feedbacktext = $this->getpath($answer, array('#', 'feedback', 0, '#', 'text', 0, '#'), '', true);
|
|
$feedbackformat = $this->trans_format($this->getpath($answer, array('#', 'feedback', 0, '@', 'format'), ''));
|
|
$feedbackfiles = array();
|
|
$files = $this->getpath($answer, array('#', 'feedback', 0, '#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->name = $file['@']['name'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$feedbackfiles[] = $data;
|
|
}
|
|
|
|
$ans = new stdclass;
|
|
|
|
$ans->answer = array();
|
|
$ans->answer['text'] = $answertext;
|
|
$ans->answer['format'] = $answerformat;
|
|
$ans->answer['files'] = $answerfiles;
|
|
|
|
$ans->feedback = array();
|
|
$ans->feedback['text'] = $feedbacktext;
|
|
$ans->feedback['format'] = $feedbackformat;
|
|
$ans->feedback['files'] = $feedbackfiles;
|
|
|
|
$ans->fraction = $fraction / 100;
|
|
return $ans;
|
|
}
|
|
|
|
/**
|
|
* import multiple choice question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_multichoice($question) {
|
|
// get common parts
|
|
$qo = $this->import_headers($question);
|
|
|
|
// 'header' parts particular to multichoice
|
|
$qo->qtype = MULTICHOICE;
|
|
$single = $this->getpath( $question, array('#','single',0,'#'), 'true' );
|
|
$qo->single = $this->trans_single( $single );
|
|
$shuffleanswers = $this->getpath( $question, array('#','shuffleanswers',0,'#'), 'false' );
|
|
$qo->answernumbering = $this->getpath( $question, array('#','answernumbering',0,'#'), 'abc' );
|
|
$qo->shuffleanswers = $this->trans_single($shuffleanswers);
|
|
|
|
$qo->correctfeedback = array();
|
|
$qo->correctfeedback['text'] = $this->getpath($question, array('#', 'correctfeedback', 0, '#', 'text', 0, '#'), '', true);
|
|
$qo->correctfeedback['format'] = $this->trans_format($this->getpath($question, array('#', 'correctfeedback', 0, '@', 'format'), ''));
|
|
$qo->correctfeedback['files'] = array();
|
|
// restore files in correctfeedback
|
|
$files = $this->getpath($question, array('#', 'correctfeedback', 0, '#','file'), array(), false);
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->correctfeedback['files'][] = $data;
|
|
}
|
|
|
|
$qo->partiallycorrectfeedback = array();
|
|
$qo->partiallycorrectfeedback['text'] = $this->getpath( $question, array('#','partiallycorrectfeedback',0,'#','text',0,'#'), '', true );
|
|
$qo->partiallycorrectfeedback['format'] = $this->trans_format($this->getpath($question, array('#', 'partiallycorrectfeedback', 0, '@', 'format'), ''));
|
|
$qo->partiallycorrectfeedback['files'] = array();
|
|
// restore files in partiallycorrectfeedback
|
|
$files = $this->getpath($question, array('#', 'partiallycorrectfeedback', 0, '#','file'), array(), false);
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->partiallycorrectfeedback['files'][] = $data;
|
|
}
|
|
|
|
$qo->incorrectfeedback = array();
|
|
$qo->incorrectfeedback['text'] = $this->getpath( $question, array('#','incorrectfeedback',0,'#','text',0,'#'), '', true );
|
|
$qo->incorrectfeedback['format'] = $this->trans_format($this->getpath($question, array('#', 'incorrectfeedback', 0, '@', 'format'), ''));
|
|
$qo->incorrectfeedback['files'] = array();
|
|
// restore files in incorrectfeedback
|
|
$files = $this->getpath($question, array('#', 'incorrectfeedback', 0, '#','file'), array(), false);
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->incorrectfeedback['files'][] = $data;
|
|
}
|
|
|
|
// There was a time on the 1.8 branch when it could output an empty answernumbering tag, so fix up any found.
|
|
if (empty($qo->answernumbering)) {
|
|
$qo->answernumbering = 'abc';
|
|
}
|
|
|
|
// run through the answers
|
|
$answers = $question['#']['answer'];
|
|
$a_count = 0;
|
|
foreach ($answers as $answer) {
|
|
$ans = $this->import_answer($answer);
|
|
$qo->answer[$a_count] = $ans->answer;
|
|
$qo->fraction[$a_count] = $ans->fraction;
|
|
$qo->feedback[$a_count] = $ans->feedback;
|
|
++$a_count;
|
|
}
|
|
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import cloze type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_multianswer( $questions ) {
|
|
$questiontext = $questions['#']['questiontext'][0]['#']['text'];
|
|
$qo = qtype_multianswer_extract_question($this->import_text($questiontext));
|
|
|
|
// 'header' parts particular to multianswer
|
|
$qo->qtype = MULTIANSWER;
|
|
$qo->course = $this->course;
|
|
$qo->generalfeedback = $this->getpath( $questions, array('#','generalfeedback',0,'#','text',0,'#'), '', true );
|
|
|
|
if (!empty($questions)) {
|
|
$qo->name = $this->import_text( $questions['#']['name'][0]['#']['text'] );
|
|
}
|
|
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import true/false type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_truefalse( $question ) {
|
|
// get common parts
|
|
global $OUTPUT;
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// 'header' parts particular to true/false
|
|
$qo->qtype = TRUEFALSE;
|
|
|
|
// get answer info
|
|
//
|
|
// In the past, it used to be assumed that the two answers were in the file
|
|
// true first, then false. Howevever that was not always true. Now, we
|
|
// try to match on the answer text, but in old exports, this will be a localised
|
|
// string, so if we don't find true or false, we fall back to the old system.
|
|
$first = true;
|
|
$warning = false;
|
|
foreach ($question['#']['answer'] as $answer) {
|
|
$answertext = $this->getpath( $answer, array('#','text',0,'#'), '', true );
|
|
$feedback = $this->getpath($answer, array('#','feedback',0,'#','text',0,'#'), '', true);
|
|
$feedbackformat = $this->getpath($answer, array('#','feedback',0, '@', 'format'), '', true);
|
|
$feedbackfiles = $this->getpath($answer, array('#', 'feedback', 0, '#', 'file'), array(), false);
|
|
$files = array();
|
|
foreach ($feedbackfiles as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$files[] = $data;
|
|
}
|
|
if ($answertext != 'true' && $answertext != 'false') {
|
|
$warning = true;
|
|
$answertext = $first ? 'true' : 'false'; // Old style file, assume order is true/false.
|
|
}
|
|
if ($answertext == 'true') {
|
|
$qo->answer = ($answer['@']['fraction'] == 100);
|
|
$qo->correctanswer = $qo->answer;
|
|
$qo->feedbacktrue = array();
|
|
$qo->feedbacktrue['text'] = $feedback;
|
|
$qo->feedbacktrue['format'] = $this->trans_format($feedbackformat);
|
|
$qo->feedbacktrue['itemid'] = null;
|
|
$qo->feedbacktruefiles = $files;
|
|
} else {
|
|
$qo->answer = ($answer['@']['fraction'] != 100);
|
|
$qo->correctanswer = $qo->answer;
|
|
$qo->feedbackfalse = array();
|
|
$qo->feedbackfalse['text'] = $feedback;
|
|
$qo->feedbackfalse['format'] = $this->trans_format($feedbackformat);
|
|
$qo->feedbackfalse['itemid'] = null;
|
|
$qo->feedbackfalsefiles = $files;
|
|
}
|
|
$first = false;
|
|
}
|
|
|
|
if ($warning) {
|
|
$a = new stdClass;
|
|
$a->questiontext = $qo->questiontext;
|
|
$a->answer = get_string($qo->answer ? 'true' : 'false', 'quiz');
|
|
echo $OUTPUT->notification(get_string('truefalseimporterror', 'quiz', $a));
|
|
}
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import short answer type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_shortanswer( $question ) {
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// header parts particular to shortanswer
|
|
$qo->qtype = SHORTANSWER;
|
|
|
|
// get usecase
|
|
$qo->usecase = $this->getpath($question, array('#','usecase',0,'#'), $qo->usecase );
|
|
|
|
// run through the answers
|
|
$answers = $question['#']['answer'];
|
|
$a_count = 0;
|
|
foreach ($answers as $answer) {
|
|
$ans = $this->import_answer( $answer );
|
|
$qo->answer[$a_count] = $ans->answer;
|
|
$qo->fraction[$a_count] = $ans->fraction;
|
|
$qo->feedback[$a_count] = $ans->feedback;
|
|
++$a_count;
|
|
}
|
|
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import description type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_description( $question ) {
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
// header parts particular to shortanswer
|
|
$qo->qtype = DESCRIPTION;
|
|
$qo->defaultgrade = 0;
|
|
$qo->length = 0;
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import numerical type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_numerical( $question ) {
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// header parts particular to numerical
|
|
$qo->qtype = NUMERICAL;
|
|
|
|
// get answers array
|
|
$answers = $question['#']['answer'];
|
|
$qo->answer = array();
|
|
$qo->feedback = array();
|
|
$qo->fraction = array();
|
|
$qo->tolerance = array();
|
|
foreach ($answers as $answer) {
|
|
// answer outside of <text> is deprecated
|
|
$obj = $this->import_answer($answer);
|
|
$qo->answer[] = $obj->answer;
|
|
if (empty($qo->answer)) {
|
|
$qo->answer = '*';
|
|
}
|
|
$qo->feedback[] = $obj->feedback;
|
|
$qo->tolerance[] = $this->getpath( $answer, array('#','tolerance',0,'#'), 0 );
|
|
|
|
// fraction as a tag is deprecated
|
|
$fraction = $this->getpath( $answer, array('@','fraction'), 0 ) / 100;
|
|
$qo->fraction[] = $this->getpath( $answer, array('#','fraction',0,'#'), $fraction ); // deprecated
|
|
}
|
|
|
|
// get units array
|
|
$qo->unit = array();
|
|
$units = $this->getpath( $question, array('#','units',0,'#','unit'), array() );
|
|
if (!empty($units)) {
|
|
$qo->multiplier = array();
|
|
foreach ($units as $unit) {
|
|
$qo->multiplier[] = $this->getpath( $unit, array('#','multiplier',0,'#'), 1 );
|
|
$qo->unit[] = $this->getpath( $unit, array('#','unit_name',0,'#'), '', true );
|
|
}
|
|
}
|
|
$qo->unitgradingtype = $this->getpath( $question, array('#','unitgradingtype',0,'#'), 0 );
|
|
$qo->unitpenalty = $this->getpath( $question, array('#','unitpenalty',0,'#'), 0 );
|
|
$qo->showunits = $this->getpath( $question, array('#','showunits',0,'#'), 0 );
|
|
$qo->unitsleft = $this->getpath( $question, array('#','unitsleft',0,'#'), 0 );
|
|
$instructions = $this->getpath($question, array('#', 'instructions'), array());
|
|
if (!empty($instructions)) {
|
|
$qo->instructions = array();
|
|
$qo->instructions['text'] = $instructions[0]['#']['text'][0]['#'];
|
|
$qo->instructions['format'] = $this->trans_format($instructions[0]['@']['format']);
|
|
$files = $instructions[0]['#']['file'];
|
|
$qo->instructionsfiles = array();
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->instructionsfiles[] = $data;
|
|
}
|
|
}
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import matching type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_matching( $question ) {
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// header parts particular to matching
|
|
$qo->qtype = MATCH;
|
|
$qo->shuffleanswers = $this->getpath( $question, array( '#','shuffleanswers',0,'#' ), 1 );
|
|
|
|
// get subquestions
|
|
$subquestions = $question['#']['subquestion'];
|
|
$qo->subquestions = array();
|
|
$qo->subanswers = array();
|
|
|
|
// run through subquestions
|
|
foreach ($subquestions as $subquestion) {
|
|
$question = array();
|
|
$question['text'] = $this->getpath($subquestion, array('#', 'text', 0, '#'), '', true);
|
|
$question['format'] = $this->trans_format($this->getpath($subquestion, array('@', 'format'), '', true));
|
|
$question['files'] = array();
|
|
|
|
$files = $this->getpath($subquestion, array('#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass();
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$question['files'][] = $data;
|
|
}
|
|
$qo->subquestions[] = $question;
|
|
$answers = $this->getpath($subquestion, array('#', 'answer'), array());
|
|
$qo->subanswers[] = $this->getpath($subquestion, array('#','answer',0,'#','text',0,'#'), '', true);
|
|
}
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* import essay type question
|
|
* @param array question question array from xml tree
|
|
* @return object question object
|
|
*/
|
|
function import_essay( $question ) {
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// header parts particular to essay
|
|
$qo->qtype = ESSAY;
|
|
|
|
$answers = $question['#']['answer'];
|
|
$answer = array_pop($answers);
|
|
$answer = $this->import_answer($answer);
|
|
// get feedback
|
|
$qo->feedback = $answer->feedback;
|
|
|
|
// get fraction - <fraction> tag is deprecated
|
|
$qo->fraction = $this->getpath( $question, array('@','fraction'), 0 ) / 100;
|
|
$q0->fraction = $this->getpath( $question, array('#','fraction',0,'#'), $qo->fraction );
|
|
|
|
return $qo;
|
|
}
|
|
|
|
function import_calculated($question,$qtype) {
|
|
// import calculated question
|
|
|
|
// get common parts
|
|
$qo = $this->import_headers( $question );
|
|
|
|
// header parts particular to calculated
|
|
$qo->qtype = CALCULATED ;//CALCULATED;
|
|
$qo->synchronize = $this->getpath( $question, array( '#','synchronize',0,'#' ), 0 );
|
|
$single = $this->getpath( $question, array('#','single',0,'#'), 'true' );
|
|
$qo->single = $this->trans_single( $single );
|
|
$shuffleanswers = $this->getpath( $question, array('#','shuffleanswers',0,'#'), 'false' );
|
|
$qo->answernumbering = $this->getpath( $question, array('#','answernumbering',0,'#'), 'abc' );
|
|
$qo->shuffleanswers = $this->trans_single($shuffleanswers);
|
|
|
|
$qo->correctfeedback = array();
|
|
$qo->correctfeedback['text'] = $this->getpath( $question, array('#','correctfeedback',0,'#','text',0,'#'), '', true );
|
|
$qo->correctfeedback['format'] = $this->trans_format($this->getpath( $question, array('#', 'correctfeedback', 0, '@', 'formath'), '', true ));
|
|
$qo->correctfeedback['files'] = array();
|
|
|
|
$files = $this->getpath($question, array('#', 'correctfeedback', '0', '#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass();
|
|
$data->content = $file['#'];
|
|
$data->name = $file['@']['name'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$qo->correctfeedback['files'][] = $data;
|
|
}
|
|
|
|
$qo->partiallycorrectfeedback = array();
|
|
$qo->partiallycorrectfeedback['text'] = $this->getpath( $question, array('#','partiallycorrectfeedback',0,'#','text',0,'#'), '', true );
|
|
$qo->partiallycorrectfeedback['format'] = $this->trans_format($this->getpath($question, array('#','partiallycorrectfeedback', 0, '@','format'), '', true ));
|
|
$qo->partiallycorrectfeedback['files'] = array();
|
|
|
|
$files = $this->getpath($question, array('#', 'partiallycorrectfeedback', '0', '#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass();
|
|
$data->content = $file['#'];
|
|
$data->name = $file['@']['name'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$qo->partiallycorrectfeedback['files'][] = $data;
|
|
}
|
|
|
|
$qo->incorrectfeedback = array();
|
|
$qo->incorrectfeedback['text'] = $this->getpath( $question, array('#','incorrectfeedback',0,'#','text',0,'#'), '', true );
|
|
$qo->incorrectfeedback['format'] = $this->trans_format($this->getpath($question, array('#','incorrectfeedback', 0, '@','format'), '', true ));
|
|
$qo->incorrectfeedback['files'] = array();
|
|
|
|
$files = $this->getpath($question, array('#', 'incorrectfeedback', '0', '#', 'file'), array());
|
|
foreach ($files as $file) {
|
|
$data = new stdclass();
|
|
$data->content = $file['#'];
|
|
$data->name = $file['@']['name'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$qo->incorrectfeedback['files'][] = $data;
|
|
}
|
|
|
|
$qo->unitgradingtype = $this->getpath( $question, array('#','unitgradingtype',0,'#'), 0 );
|
|
$qo->unitpenalty = $this->getpath( $question, array('#','unitpenalty',0,'#'), 0 );
|
|
$qo->showunits = $this->getpath( $question, array('#','showunits',0,'#'), 0 );
|
|
$qo->unitsleft = $this->getpath( $question, array('#','unitsleft',0,'#'), 0 );
|
|
// $qo->instructions = $this->getpath( $question, array('#','instructions',0,'#','text',0,'#'), '', true );
|
|
if (!empty($instructions)) {
|
|
$qo->instructions = array();
|
|
$qo->instructions['text'] = $instructions[0]['#']['text'][0]['#'];
|
|
$qo->instructions['format'] = $this->trans_format($instructions[0]['@']['format']);
|
|
$files = $instructions[0]['#']['file'];
|
|
$qo->instructionsfiles = array();
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->instructionsfiles[] = $data;
|
|
}
|
|
}
|
|
|
|
$files = $this->getpath($question, array('#', 'instructions', 0, '#', 'file', 0, '@'), '', false);
|
|
|
|
// get answers array
|
|
// echo "<pre> question";print_r($question);echo "</pre>";
|
|
$answers = $question['#']['answer'];
|
|
$qo->answers = array();
|
|
$qo->feedback = array();
|
|
$qo->fraction = array();
|
|
$qo->tolerance = array();
|
|
$qo->tolerancetype = array();
|
|
$qo->correctanswerformat = array();
|
|
$qo->correctanswerlength = array();
|
|
$qo->feedback = array();
|
|
foreach ($answers as $answer) {
|
|
$ans = $this->import_answer($answer);
|
|
// answer outside of <text> is deprecated
|
|
if (empty($ans->answer['text'])) {
|
|
$ans->answer['text'] = '*';
|
|
}
|
|
$qo->answers[] = $ans->answer;
|
|
$qo->feedback[] = $ans->feedback;
|
|
$qo->tolerance[] = $answer['#']['tolerance'][0]['#'];
|
|
// fraction as a tag is deprecated
|
|
if (!empty($answer['#']['fraction'][0]['#'])) {
|
|
$qo->fraction[] = $answer['#']['fraction'][0]['#'];
|
|
} else {
|
|
$qo->fraction[] = $answer['@']['fraction'] / 100;
|
|
}
|
|
$qo->tolerancetype[] = $answer['#']['tolerancetype'][0]['#'];
|
|
$qo->correctanswerformat[] = $answer['#']['correctanswerformat'][0]['#'];
|
|
$qo->correctanswerlength[] = $answer['#']['correctanswerlength'][0]['#'];
|
|
}
|
|
// get units array
|
|
$qo->unit = array();
|
|
if (isset($question['#']['units'][0]['#']['unit'])) {
|
|
$units = $question['#']['units'][0]['#']['unit'];
|
|
$qo->multiplier = array();
|
|
foreach ($units as $unit) {
|
|
$qo->multiplier[] = $unit['#']['multiplier'][0]['#'];
|
|
$qo->unit[] = $unit['#']['unit_name'][0]['#'];
|
|
}
|
|
}
|
|
$instructions = $this->getpath($question, array('#', 'instructions'), array());
|
|
if (!empty($instructions)) {
|
|
$qo->instructions = array();
|
|
$qo->instructions['text'] = $instructions[0]['#']['text'][0]['#'];
|
|
$qo->instructions['format'] = $this->trans_format($instructions[0]['@']['format']);
|
|
$qo->instructionsfiles = array();
|
|
if (isset($instructions[0]['#']['file'])) {
|
|
$files = $instructions[0]['#']['file'];
|
|
foreach ($files as $file) {
|
|
$data = new stdclass;
|
|
$data->content = $file['#'];
|
|
$data->encoding = $file['@']['encoding'];
|
|
$data->name = $file['@']['name'];
|
|
$qo->instructionsfiles[] = $data;
|
|
}
|
|
}
|
|
}
|
|
$datasets = $question['#']['dataset_definitions'][0]['#']['dataset_definition'];
|
|
$qo->dataset = array();
|
|
$qo->datasetindex= 0 ;
|
|
foreach ($datasets as $dataset) {
|
|
$qo->datasetindex++;
|
|
$qo->dataset[$qo->datasetindex] = new stdClass();
|
|
$qo->dataset[$qo->datasetindex]->status = $this->import_text( $dataset['#']['status'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->name = $this->import_text( $dataset['#']['name'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->type = $dataset['#']['type'][0]['#'];
|
|
$qo->dataset[$qo->datasetindex]->distribution = $this->import_text( $dataset['#']['distribution'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->max = $this->import_text( $dataset['#']['maximum'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->min = $this->import_text( $dataset['#']['minimum'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->length = $this->import_text( $dataset['#']['decimals'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->distribution = $this->import_text( $dataset['#']['distribution'][0]['#']['text']);
|
|
$qo->dataset[$qo->datasetindex]->itemcount = $dataset['#']['itemcount'][0]['#'];
|
|
$qo->dataset[$qo->datasetindex]->datasetitem = array();
|
|
$qo->dataset[$qo->datasetindex]->itemindex = 0;
|
|
$qo->dataset[$qo->datasetindex]->number_of_items=$dataset['#']['number_of_items'][0]['#'];
|
|
$datasetitems = $dataset['#']['dataset_items'][0]['#']['dataset_item'];
|
|
foreach ($datasetitems as $datasetitem) {
|
|
$qo->dataset[$qo->datasetindex]->itemindex++;
|
|
$qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex] = new stdClass();
|
|
$qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex]->itemnumber = $datasetitem['#']['number'][0]['#']; //[0]['#']['number'][0]['#'] ; // [0]['numberitems'] ;//['#']['number'][0]['#'];// $datasetitems['#']['number'][0]['#'];
|
|
$qo->dataset[$qo->datasetindex]->datasetitem[$qo->dataset[$qo->datasetindex]->itemindex]->value = $datasetitem['#']['value'][0]['#'] ;//$datasetitem['#']['value'][0]['#'];
|
|
}
|
|
}
|
|
|
|
// echo "<pre>loaded qo";print_r($qo);echo "</pre>";
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* this is not a real question type. It's a dummy type used
|
|
* to specify the import category
|
|
* format is:
|
|
* <question type="category">
|
|
* <category>tom/dick/harry</category>
|
|
* </question>
|
|
*/
|
|
function import_category( $question ) {
|
|
$qo = new stdClass;
|
|
$qo->qtype = 'category';
|
|
$qo->category = $this->import_text($question['#']['category'][0]['#']['text']);
|
|
return $qo;
|
|
}
|
|
|
|
/**
|
|
* parse the array of lines into an array of questions
|
|
* this *could* burn memory - but it won't happen that much
|
|
* so fingers crossed!
|
|
* @param array lines array of lines from the input file
|
|
* @return array (of objects) question objects
|
|
*/
|
|
function readquestions($lines) {
|
|
// we just need it as one big string
|
|
$text = implode($lines, " ");
|
|
unset($lines);
|
|
|
|
// this converts xml to big nasty data structure
|
|
// the 0 means keep white space as it is (important for markdown format)
|
|
// print_r it if you want to see what it looks like!
|
|
$xml = xmlize($text, 0);
|
|
|
|
// set up array to hold all our questions
|
|
$questions = array();
|
|
|
|
// iterate through questions
|
|
foreach ($xml['quiz']['#']['question'] as $question) {
|
|
$question_type = $question['@']['type'];
|
|
$questiontype = get_string( 'questiontype','quiz',$question_type );
|
|
|
|
if ($question_type=='multichoice') {
|
|
$qo = $this->import_multichoice( $question );
|
|
}
|
|
elseif ($question_type=='truefalse') {
|
|
$qo = $this->import_truefalse( $question );
|
|
}
|
|
elseif ($question_type=='shortanswer') {
|
|
$qo = $this->import_shortanswer( $question );
|
|
}
|
|
elseif ($question_type=='numerical') {
|
|
$qo = $this->import_numerical( $question );
|
|
}
|
|
elseif ($question_type=='description') {
|
|
$qo = $this->import_description( $question );
|
|
}
|
|
elseif ($question_type=='matching') {
|
|
$qo = $this->import_matching( $question );
|
|
}
|
|
elseif ($question_type=='cloze') {
|
|
$qo = $this->import_multianswer( $question );
|
|
}
|
|
elseif ($question_type=='essay') {
|
|
$qo = $this->import_essay( $question );
|
|
}
|
|
elseif ($question_type=='calculated') {
|
|
$qo = $this->import_calculated( $question,CALCULATED );
|
|
}
|
|
elseif ($question_type=='calculatedsimple') {
|
|
$qo = $this->import_calculated( $question,CALCULATEDMULTI );
|
|
$qo->qtype = CALCULATEDSIMPLE ;
|
|
}
|
|
elseif ($question_type=='calculatedmulti') {
|
|
$qo = $this->import_calculated( $question,CALCULATEDMULTI );
|
|
$qo->qtype = CALCULATEDMULTI ;
|
|
}
|
|
elseif ($question_type=='category') {
|
|
$qo = $this->import_category( $question );
|
|
}
|
|
else {
|
|
// try for plugin support
|
|
// no default question, as the plugin can call
|
|
// import_headers() itself if it wants to
|
|
if (!$qo = $this->try_importing_using_qtypes( $question, null, null, $question_type)) {
|
|
$notsupported = get_string( 'xmltypeunsupported','quiz',$question_type );
|
|
$this->error( $notsupported );
|
|
$qo = null;
|
|
}
|
|
}
|
|
|
|
// stick the result in the $questions array
|
|
if ($qo) {
|
|
$questions[] = $qo;
|
|
}
|
|
}
|
|
return $questions;
|
|
}
|
|
|
|
// EXPORT FUNCTIONS START HERE
|
|
|
|
function export_file_extension() {
|
|
// override default type so extension is .xml
|
|
|
|
return ".xml";
|
|
}
|
|
|
|
|
|
/**
|
|
* Turn the internal question code into a human readable form
|
|
* (The code used to be numeric, but this remains as some of
|
|
* the names don't match the new internal format)
|
|
* @param mixed type_id Internal code
|
|
* @return string question type string
|
|
*/
|
|
function get_qtype( $type_id ) {
|
|
switch( $type_id ) {
|
|
case TRUEFALSE:
|
|
$name = 'truefalse';
|
|
break;
|
|
case MULTICHOICE:
|
|
$name = 'multichoice';
|
|
break;
|
|
case SHORTANSWER:
|
|
$name = 'shortanswer';
|
|
break;
|
|
case NUMERICAL:
|
|
$name = 'numerical';
|
|
break;
|
|
case MATCH:
|
|
$name = 'matching';
|
|
break;
|
|
case DESCRIPTION:
|
|
$name = 'description';
|
|
break;
|
|
case MULTIANSWER:
|
|
$name = 'cloze';
|
|
break;
|
|
case ESSAY:
|
|
$name = 'essay';
|
|
break;
|
|
case CALCULATED:
|
|
$name = 'calculated';
|
|
break;
|
|
case CALCULATEDSIMPLE:
|
|
$name = 'calculatedsimple';
|
|
break;
|
|
case CALCULATEDMULTI:
|
|
$name = 'calculatedmulti';
|
|
break;
|
|
default:
|
|
$name = false;
|
|
}
|
|
return $name;
|
|
}
|
|
|
|
/**
|
|
* Convert internal Moodle text format code into
|
|
* human readable form
|
|
* @param int id internal code
|
|
* @return string format text
|
|
*/
|
|
function get_format( $id ) {
|
|
switch( $id ) {
|
|
case 0:
|
|
$name = "moodle_auto_format";
|
|
break;
|
|
case 1:
|
|
$name = "html";
|
|
break;
|
|
case 2:
|
|
$name = "plain_text";
|
|
break;
|
|
case 3:
|
|
$name = "wiki_like";
|
|
break;
|
|
case 4:
|
|
$name = "markdown";
|
|
break;
|
|
default:
|
|
$name = "unknown";
|
|
}
|
|
return $name;
|
|
}
|
|
|
|
/**
|
|
* Convert internal single question code into
|
|
* human readable form
|
|
* @param int id single question code
|
|
* @return string single question string
|
|
*/
|
|
function get_single( $id ) {
|
|
switch( $id ) {
|
|
case 0:
|
|
$name = "false";
|
|
break;
|
|
case 1:
|
|
$name = "true";
|
|
break;
|
|
default:
|
|
$name = "unknown";
|
|
}
|
|
return $name;
|
|
}
|
|
|
|
/**
|
|
* generates <text></text> tags, processing raw text therein
|
|
* @param int ilev the current indent level
|
|
* @param boolean short stick it on one line
|
|
* @return string formatted text
|
|
*/
|
|
function writetext($raw, $ilev=0, $short=true) {
|
|
$indent = str_repeat( " ",$ilev );
|
|
|
|
// if required add CDATA tags
|
|
if (!empty($raw) and (htmlspecialchars($raw)!=$raw)) {
|
|
$raw = "<![CDATA[$raw]]>";
|
|
}
|
|
|
|
if ($short) {
|
|
$xml = "$indent<text>$raw</text>\n";
|
|
}
|
|
else {
|
|
$xml = "$indent<text>\n$raw\n$indent</text>\n";
|
|
}
|
|
|
|
return $xml;
|
|
}
|
|
|
|
function xmltidy( $content ) {
|
|
// can only do this if tidy is installed
|
|
if (extension_loaded('tidy')) {
|
|
$config = array( 'input-xml'=>true, 'output-xml'=>true, 'indent'=>true, 'wrap'=>0 );
|
|
$tidy = new tidy;
|
|
$tidy->parseString($content, $config, 'utf8');
|
|
$tidy->cleanRepair();
|
|
return $tidy->value;
|
|
}
|
|
else {
|
|
return $content;
|
|
}
|
|
}
|
|
|
|
|
|
function presave_process( $content ) {
|
|
// override method to allow us to add xml headers and footers
|
|
|
|
// add the xml headers and footers
|
|
$content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" .
|
|
"<quiz>\n" .
|
|
$content . "\n" .
|
|
"</quiz>";
|
|
|
|
// make the xml look nice
|
|
$content = $this->xmltidy( $content );
|
|
|
|
return $content;
|
|
}
|
|
|
|
/**
|
|
* Turns question into an xml segment
|
|
* @param object question object
|
|
* @param int context id
|
|
* @return string xml segment
|
|
*/
|
|
function writequestion($question) {
|
|
global $CFG, $QTYPES, $OUTPUT;
|
|
|
|
$fs = get_file_storage();
|
|
$contextid = $question->contextid;
|
|
// initial string;
|
|
$expout = "";
|
|
|
|
// add comment
|
|
$expout .= "\n\n<!-- question: $question->id -->\n";
|
|
|
|
// check question type
|
|
if (!$question_type = $this->get_qtype( $question->qtype )) {
|
|
// must be a plugin then, so just accept the name supplied
|
|
$question_type = $question->qtype;
|
|
}
|
|
|
|
// add opening tag
|
|
// generates specific header for Cloze and category type question
|
|
if ($question->qtype == 'category') {
|
|
$categorypath = $this->writetext( $question->category );
|
|
$expout .= " <question type=\"category\">\n";
|
|
$expout .= " <category>\n";
|
|
$expout .= " $categorypath\n";
|
|
$expout .= " </category>\n";
|
|
$expout .= " </question>\n";
|
|
return $expout;
|
|
} elseif ($question->qtype != MULTIANSWER) {
|
|
// for all question types except Close
|
|
$name_text = $this->writetext($question->name);
|
|
$qtformat = $this->get_format($question->questiontextformat);
|
|
$generalfeedbackformat = $this->get_format($question->generalfeedbackformat);
|
|
|
|
$question_text = $this->writetext($question->questiontext);
|
|
$question_text_files = $this->writefiles($question->questiontextfiles);
|
|
|
|
$generalfeedback = $this->writetext($question->generalfeedback);
|
|
$generalfeedback_files = $this->writefiles($question->generalfeedbackfiles);
|
|
|
|
$expout .= " <question type=\"$question_type\">\n";
|
|
$expout .= " <name>$name_text</name>\n";
|
|
$expout .= " <questiontext format=\"$qtformat\">\n";
|
|
$expout .= $question_text;
|
|
$expout .= $question_text_files;
|
|
$expout .= " </questiontext>\n";
|
|
$expout .= " <generalfeedback format=\"$generalfeedbackformat\">\n";
|
|
$expout .= $generalfeedback;
|
|
$expout .= $generalfeedback_files;
|
|
$expout .= " </generalfeedback>\n";
|
|
$expout .= " <defaultgrade>{$question->defaultgrade}</defaultgrade>\n";
|
|
$expout .= " <penalty>{$question->penalty}</penalty>\n";
|
|
$expout .= " <hidden>{$question->hidden}</hidden>\n";
|
|
} else {
|
|
// for Cloze type only
|
|
$name_text = $this->writetext( $question->name );
|
|
$question_text = $this->writetext( $question->questiontext );
|
|
$generalfeedback = $this->writetext( $question->generalfeedback );
|
|
$expout .= " <question type=\"$question_type\">\n";
|
|
$expout .= " <name>$name_text</name>\n";
|
|
$expout .= " <questiontext>\n";
|
|
$expout .= $question_text;
|
|
$expout .= " </questiontext>\n";
|
|
$expout .= " <generalfeedback>\n";
|
|
$expout .= $generalfeedback;
|
|
$expout .= " </generalfeedback>\n";
|
|
}
|
|
|
|
if (!empty($question->options->shuffleanswers)) {
|
|
$expout .= " <shuffleanswers>{$question->options->shuffleanswers}</shuffleanswers>\n";
|
|
}
|
|
else {
|
|
$expout .= " <shuffleanswers>0</shuffleanswers>\n";
|
|
}
|
|
|
|
// output depends on question type
|
|
switch($question->qtype) {
|
|
case 'category':
|
|
// not a qtype really - dummy used for category switching
|
|
break;
|
|
case TRUEFALSE:
|
|
foreach ($question->options->answers as $answer) {
|
|
$fraction_pc = round( $answer->fraction * 100 );
|
|
if ($answer->id == $question->options->trueanswer) {
|
|
$answertext = 'true';
|
|
} else {
|
|
$answertext = 'false';
|
|
}
|
|
$expout .= " <answer fraction=\"$fraction_pc\">\n";
|
|
$expout .= $this->writetext($answertext, 3) . "\n";
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback,4,false);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
$expout .= " </answer>\n";
|
|
}
|
|
break;
|
|
case MULTICHOICE:
|
|
$expout .= " <single>".$this->get_single($question->options->single)."</single>\n";
|
|
$expout .= " <shuffleanswers>".$this->get_single($question->options->shuffleanswers)."</shuffleanswers>\n";
|
|
|
|
$textformat = $this->get_format($question->options->correctfeedbackformat);
|
|
$files = $fs->get_area_files($contextid, 'qtype_multichoice', 'correctfeedback', $question->id);
|
|
$expout .= " <correctfeedback format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($question->options->correctfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </correctfeedback>\n";
|
|
|
|
$textformat = $this->get_format($question->options->partiallycorrectfeedbackformat);
|
|
$files = $fs->get_area_files($contextid, 'qtype_multichoice', 'partiallycorrectfeedback', $question->id);
|
|
$expout .= " <partiallycorrectfeedback format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($question->options->partiallycorrectfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </partiallycorrectfeedback>\n";
|
|
|
|
$textformat = $this->get_format($question->options->incorrectfeedbackformat);
|
|
$files = $fs->get_area_files($contextid, 'qtype_multichoice', 'incorrectfeedback', $question->id);
|
|
$expout .= " <incorrectfeedback format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($question->options->incorrectfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </incorrectfeedback>\n";
|
|
|
|
$expout .= " <answernumbering>".$this->writetext($question->options->answernumbering, 3)."</answernumbering>\n";
|
|
foreach($question->options->answers as $answer) {
|
|
$percent = $answer->fraction * 100;
|
|
$expout .= " <answer fraction=\"$percent\">\n";
|
|
$expout .= $this->writetext($answer->answer,4,false);
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback,5,false);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
$expout .= " </answer>\n";
|
|
}
|
|
break;
|
|
case SHORTANSWER:
|
|
$expout .= " <usecase>{$question->options->usecase}</usecase>\n ";
|
|
foreach($question->options->answers as $answer) {
|
|
$percent = 100 * $answer->fraction;
|
|
$expout .= " <answer fraction=\"$percent\">\n";
|
|
$expout .= $this->writetext( $answer->answer,3,false );
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
$expout .= " </answer>\n";
|
|
}
|
|
break;
|
|
case NUMERICAL:
|
|
foreach ($question->options->answers as $answer) {
|
|
$tolerance = $answer->tolerance;
|
|
$percent = 100 * $answer->fraction;
|
|
$expout .= "<answer fraction=\"$percent\">\n";
|
|
// <text> tags are an added feature, old filed won't have them
|
|
$expout .= " <text>{$answer->answer}</text>\n";
|
|
$expout .= " <tolerance>$tolerance</tolerance>\n";
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
// fraction tag is deprecated
|
|
// $expout .= " <fraction>{$answer->fraction}</fraction>\n";
|
|
$expout .= "</answer>\n";
|
|
}
|
|
|
|
$units = $question->options->units;
|
|
if (count($units)) {
|
|
$expout .= "<units>\n";
|
|
foreach ($units as $unit) {
|
|
$expout .= " <unit>\n";
|
|
$expout .= " <multiplier>{$unit->multiplier}</multiplier>\n";
|
|
$expout .= " <unit_name>{$unit->unit}</unit_name>\n";
|
|
$expout .= " </unit>\n";
|
|
}
|
|
$expout .= "</units>\n";
|
|
}
|
|
if (isset($question->options->unitgradingtype)) {
|
|
$expout .= " <unitgradingtype>{$question->options->unitgradingtype}</unitgradingtype>\n";
|
|
}
|
|
if (isset($question->options->unitpenalty)) {
|
|
$expout .= " <unitpenalty>{$question->options->unitpenalty}</unitpenalty>\n";
|
|
}
|
|
if (isset($question->options->showunits)) {
|
|
$expout .= " <showunits>{$question->options->showunits}</showunits>\n";
|
|
}
|
|
if (isset($question->options->unitsleft)) {
|
|
$expout .= " <unitsleft>{$question->options->unitsleft}</unitsleft>\n";
|
|
}
|
|
if (!empty($question->options->instructionsformat)) {
|
|
$textformat = $this->get_format($question->options->instructionsformat);
|
|
$files = $fs->get_area_files($contextid, 'qtype_numerical', 'instruction', $question->id);
|
|
$expout .= " <instructions format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($question->options->instructions, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </instructions>\n";
|
|
}
|
|
break;
|
|
case MATCH:
|
|
foreach($question->options->subquestions as $subquestion) {
|
|
$files = $fs->get_area_files($contextid, 'qtype_match', 'subquestion', $subquestion->id);
|
|
$textformat = $this->get_format($subquestion->questiontextformat);
|
|
$expout .= "<subquestion format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($subquestion->questiontext);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= "<answer>";
|
|
$expout .= $this->writetext($subquestion->answertext);
|
|
$expout .= "</answer>\n";
|
|
$expout .= "</subquestion>\n";
|
|
}
|
|
break;
|
|
case DESCRIPTION:
|
|
// nothing more to do for this type
|
|
break;
|
|
case MULTIANSWER:
|
|
$a_count=1;
|
|
foreach($question->options->questions as $question) {
|
|
$thispattern = preg_quote("{#".$a_count."}"); //TODO: is this really necessary?
|
|
$thisreplace = $question->questiontext;
|
|
$expout=preg_replace("~$thispattern~", $thisreplace, $expout );
|
|
$a_count++;
|
|
}
|
|
break;
|
|
case ESSAY:
|
|
if (!empty($question->options->answers)) {
|
|
foreach ($question->options->answers as $answer) {
|
|
$percent = 100 * $answer->fraction;
|
|
$expout .= "<answer fraction=\"$percent\">\n";
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
// fraction tag is deprecated
|
|
// $expout .= " <fraction>{$answer->fraction}</fraction>\n";
|
|
$expout .= "</answer>\n";
|
|
}
|
|
}
|
|
break;
|
|
case CALCULATED:
|
|
case CALCULATEDSIMPLE:
|
|
case CALCULATEDMULTI:
|
|
$expout .= " <synchronize>{$question->options->synchronize}</synchronize>\n";
|
|
$expout .= " <single>{$question->options->single}</single>\n";
|
|
$expout .= " <answernumbering>{$question->options->answernumbering}</answernumbering>\n";
|
|
$expout .= " <shuffleanswers>".$this->writetext($question->options->shuffleanswers, 3)."</shuffleanswers>\n";
|
|
|
|
$component = 'qtype_' . $question->qtype;
|
|
$files = $fs->get_area_files($contextid, $component, 'correctfeedback', $question->id);
|
|
$expout .= " <correctfeedback>\n";
|
|
$expout .= $this->writetext($question->options->correctfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </correctfeedback>\n";
|
|
|
|
$files = $fs->get_area_files($contextid, $component, 'partiallycorrectfeedback', $question->id);
|
|
$expout .= " <partiallycorrectfeedback>\n";
|
|
$expout .= $this->writetext($question->options->partiallycorrectfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </partiallycorrectfeedback>\n";
|
|
|
|
$files = $fs->get_area_files($contextid, $component, 'incorrectfeedback', $question->id);
|
|
$expout .= " <incorrectfeedback>\n";
|
|
$expout .= $this->writetext($question->options->incorrectfeedback, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </incorrectfeedback>\n";
|
|
|
|
foreach ($question->options->answers as $answer) {
|
|
$tolerance = $answer->tolerance;
|
|
$tolerancetype = $answer->tolerancetype;
|
|
$correctanswerlength= $answer->correctanswerlength ;
|
|
$correctanswerformat= $answer->correctanswerformat;
|
|
$percent = 100 * $answer->fraction;
|
|
$expout .= "<answer fraction=\"$percent\">\n";
|
|
// "<text/>" tags are an added feature, old files won't have them
|
|
$expout .= " <text>{$answer->answer}</text>\n";
|
|
$expout .= " <tolerance>$tolerance</tolerance>\n";
|
|
$expout .= " <tolerancetype>$tolerancetype</tolerancetype>\n";
|
|
$expout .= " <correctanswerformat>$correctanswerformat</correctanswerformat>\n";
|
|
$expout .= " <correctanswerlength>$correctanswerlength</correctanswerlength>\n";
|
|
$feedbackformat = $this->get_format($answer->feedbackformat);
|
|
$expout .= " <feedback format=\"$feedbackformat\">\n";
|
|
$expout .= $this->writetext($answer->feedback);
|
|
$expout .= $this->writefiles($answer->feedbackfiles);
|
|
$expout .= " </feedback>\n";
|
|
$expout .= "</answer>\n";
|
|
}
|
|
if (isset($question->options->unitgradingtype)) {
|
|
$expout .= " <unitgradingtype>{$question->options->unitgradingtype}</unitgradingtype>\n";
|
|
}
|
|
if (isset($question->options->unitpenalty)) {
|
|
$expout .= " <unitpenalty>{$question->options->unitpenalty}</unitpenalty>\n";
|
|
}
|
|
if (isset($question->options->showunits)) {
|
|
$expout .= " <showunits>{$question->options->showunits}</showunits>\n";
|
|
}
|
|
if (isset($question->options->unitsleft)) {
|
|
$expout .= " <unitsleft>{$question->options->unitsleft}</unitsleft>\n";
|
|
}
|
|
|
|
if (isset($question->options->instructionsformat)) {
|
|
$textformat = $this->get_format($question->options->instructionsformat);
|
|
$files = $fs->get_area_files($contextid, $component, 'instruction', $question->id);
|
|
$expout .= " <instructions format=\"$textformat\">\n";
|
|
$expout .= $this->writetext($question->options->instructions, 3);
|
|
$expout .= $this->writefiles($files);
|
|
$expout .= " </instructions>\n";
|
|
}
|
|
|
|
if (isset($question->options->units)) {
|
|
$units = $question->options->units;
|
|
if (count($units)) {
|
|
$expout .= "<units>\n";
|
|
foreach ($units as $unit) {
|
|
$expout .= " <unit>\n";
|
|
$expout .= " <multiplier>{$unit->multiplier}</multiplier>\n";
|
|
$expout .= " <unit_name>{$unit->unit}</unit_name>\n";
|
|
$expout .= " </unit>\n";
|
|
}
|
|
$expout .= "</units>\n";
|
|
}
|
|
}
|
|
//The tag $question->export_process has been set so we get all the data items in the database
|
|
// from the function $QTYPES['calculated']->get_question_options(&$question);
|
|
// calculatedsimple defaults to calculated
|
|
if( isset($question->options->datasets)&&count($question->options->datasets)){// there should be
|
|
$expout .= "<dataset_definitions>\n";
|
|
foreach ($question->options->datasets as $def) {
|
|
$expout .= "<dataset_definition>\n";
|
|
$expout .= " <status>".$this->writetext($def->status)."</status>\n";
|
|
$expout .= " <name>".$this->writetext($def->name)."</name>\n";
|
|
if ( $question->qtype == CALCULATED){
|
|
$expout .= " <type>calculated</type>\n";
|
|
}else {
|
|
$expout .= " <type>calculatedsimple</type>\n";
|
|
}
|
|
$expout .= " <distribution>".$this->writetext($def->distribution)."</distribution>\n";
|
|
$expout .= " <minimum>".$this->writetext($def->minimum)."</minimum>\n";
|
|
$expout .= " <maximum>".$this->writetext($def->maximum)."</maximum>\n";
|
|
$expout .= " <decimals>".$this->writetext($def->decimals)."</decimals>\n";
|
|
$expout .= " <itemcount>$def->itemcount</itemcount>\n";
|
|
if ($def->itemcount > 0 ) {
|
|
$expout .= " <dataset_items>\n";
|
|
foreach ($def->items as $item ){
|
|
$expout .= " <dataset_item>\n";
|
|
$expout .= " <number>".$item->itemnumber."</number>\n";
|
|
$expout .= " <value>".$item->value."</value>\n";
|
|
$expout .= " </dataset_item>\n";
|
|
}
|
|
$expout .= " </dataset_items>\n";
|
|
$expout .= " <number_of_items>".$def-> number_of_items."</number_of_items>\n";
|
|
}
|
|
$expout .= "</dataset_definition>\n";
|
|
}
|
|
$expout .= "</dataset_definitions>\n";
|
|
}
|
|
break;
|
|
default:
|
|
// try support by optional plugin
|
|
if (!$data = $this->try_exporting_using_qtypes( $question->qtype, $question )) {
|
|
echo $OUTPUT->notification( get_string( 'unsupportedexport','qformat_xml',$QTYPES[$question->qtype]->local_name() ) );
|
|
}
|
|
$expout .= $data;
|
|
}
|
|
|
|
// close the question tag
|
|
$expout .= "</question>\n";
|
|
|
|
// XXX: debuging
|
|
//echo '<textarea cols=100 rows=20>';
|
|
//echo $expout;
|
|
//echo '</textarea>';
|
|
|
|
return $expout;
|
|
}
|
|
}
|