public $lang;

public function provide_export() {

return true;

}

public function indent_xhtml($source, $indenter = ' ') {

// Xml tidier-upper

// (c) Ari Koivula http://ventionline.com.

// Remove all pre-existing formatting.

// Remove all newlines.

$source = str_replace("\n", '', $source);

$source = str_replace("\r", '', $source);

// Remove all tabs.

$source = str_replace("\t", '', $source);

// Remove all space after ">" and before "<".

$source = preg_replace("/>( )*", ">/", $source);

$source = preg_replace("/( )*<", "</", $source);

// Iterate through the source.

$level = 0;

$sourcelen = strlen($source);

$pt = 0;

while ($pt < $sourcelen) {

if ($source{$pt} === '<') {

// We have entered a tag.

// Remember the point where the tag starts.

$startedat = $pt;

$taglevel = 1;

// If the second letter of the tag is "/", assume its an ending tag.

if ($source{$pt + 1} === '/') {

$taglevel = -1;

}

// If the second letter of the tag is "!", assume its an "invisible" tag.

if ($source{$pt + 1} === '!') {

$taglevel = 0;

}

// Iterate throught the source until the end of tag.

while ($source{$pt} !== '>') {

$pt++;

}

// If the second last letter is "/", assume its a self ending tag.

if ($source{$pt - 1} === '/') {

$taglevel = 0;

}

$taglenght = $pt + 1 - $startedat;

// Decide the level of indention for this tag.

// If this was an ending tag, decrease indent level for this tag..

if ($taglevel === -1) {

$level--;

}

// Place the tag in an array with proper indention.

$array[] = str_repeat($indenter, $level).substr($source, $startedat, $taglenght);

// If this was a starting tag, increase the indent level after this tag.

if ($taglevel === 1) {

$level++;

}

// If it was a self closing tag, dont do shit.

}

// Were out of the tag.

// If next letter exists...

if (($pt + 1) < $sourcelen) {

// ... and its not an "<".

if ($source{$pt + 1} !== '<') {

$startedat = $pt + 1;

// Iterate through the source until the start of new tag or until we reach the end of file.

while ($source{$pt} !== '<' && $pt < $sourcelen) {

$pt++;

}

// If we found a "<" (we didnt find the end of file).

if ($source{$pt} === '<') {

$taglenght = $pt - $startedat;

// Place the stuff in an array with proper indention.

$array[] = str_repeat($indenter, $level).substr($source, $startedat, $taglenght);

}

// If the next tag is "<", just advance pointer and let the tag indenter take care of it.

} else {

$pt++;

}

// If the next letter doesnt exist... Were done... well, almost..

} else {

break;

}

}

// Replace old source with the new one we just collected into our array.

$source = implode($array, "\n");

return $source;

}

public function importpreprocess() {

global $CFG;

print_error('cannotimportformat', 'question');

}

public function exportpreprocess() {

global $CFG;

require_once($CFG->dirroot. "/question/format/qtitwo/smarty2/libs/Smarty.class.php");

// Assign the language for the export: by parameter, SESSION, USER, or the default of 'en'.

$lang = current_language();

$this->lang = $lang;

return parent::exportpreprocess();

}

public function export_file_extension() {

// Override default type so extension is .zip.

return ".zip";

}

/**

* Take a string, and wrap it in a CDATA section, if that is required to make

* the output XML valid (copied from qformat_xml).

* @param string $string a string

* @return string the string, wrapped in CDATA if necessary.

*/

public function xml_escape($string) {

if (!empty($string) && htmlspecialchars($string) != $string) {

// If the string contains something that looks like the end

// of a CDATA section, then we need to avoid errors by splitting

// the string between two CDATA sections.

$string = str_replace(']]>', ']]]]><![CDATA[>', $string);

return "<![CDATA[{$string}]]>";

} else {

return $string;

}

}

/**

* Copies all files needed by the questions to the given $path, and flattens the file names

*

* @param array $questions the question objects

* @param string $path the full path name to where the media files need to be copied

* @param string

* @return bool

*/

public function copy_resources($questions, $dir) {

// Iterate through questions.

foreach ($questions as $question) {

$this->copy_files($question->contextid, 'question', 'questiontext', $question->id, $question->id, $dir);

$this->copy_files($question->contextid, 'question', 'generalfeedback', $question->id, $question->id, $dir);

if (!empty($question->options->answers)) {

foreach ($question->options->answers as $answer) {

$this->copy_files($question->contextid, 'question', 'answer', $question->id, $answer->id, $dir);

$this->copy_files($question->contextid, 'question', 'answerfeedback', $question->id, $answer->id, $dir);

}

}

if (!empty($question->hints)) {

foreach ($question->hints as $hint) {

$this->copy_files($question->contextid, 'question', 'hint', $question->id, $hint->id, $dir);

}

}

// The rest of the files to copy depends on question type.

switch($question->qtype) {

case 'numerical':

$this->copy_files($question->contextid, 'question', 'instruction', $question->id, $question->id, $dir);

break;

case 'match':

if (!empty($question->options->subquestions)) {

foreach ($question->options->subquestions as $subquestion) {

$this->copy_files($question->contextid, 'qtype_match', 'subquestion', $question->id, $subquestion->id, $dir);

}

}

break;

case 'essay':

$this->copy_files($question->contextid, 'qtype_essay', 'graderinfo', $question->id, $question->id, $dir);

break;

}

}

}

public function copy_files($contextid, $component, $area, $questionid, $itemid, $dir) {

global $CFG;

$destination = $dir . '/resources/' . $questionid . '/'. $component . '/' . $area . '/' . $itemid;

$directorycreated = false;

$fs = get_file_storage();

$files = $fs->get_area_files($contextid, $component, $area, $itemid);

foreach ($files as $file) {

if ($file->is_directory()) {

continue;

}

if (!$directorycreated) {

make_temp_directory($destination);

$directorycreated = true;

}

$file->copy_content_to($CFG->tempdir . '/' . $destination . '/' . $file->get_filename());

}

}

/**

* exports the questions in a question category to the given location

*

* The parent class method was overridden because the IMS export consists of multiple files

*

* @param string $filename the directory name which will hold the exported files

* @return bool - or errors out

*/

public function exportprocess() {

global $CFG, $OUTPUT, $USER, $DB;

$courseid = $this->course->id;

// Continue path for following error checks.

$continuepath = "{$CFG->wwwroot}/question/export.php?courseid={$courseid}";

// Create a temporary directory for the exports (if not already existing).

$uniquecode = time();

$this->tempdir = 'qformat_qtitwo/' . $USER->id . '/' . $uniquecode;

if (!$path = make_temp_directory($this->tempdir)) {

throw new moodle_exception('cannotcreatepath', 'question', '', $path);

print_error('cannotcreatepath', 'quiz', '', $continuepath);

}

// Get the questions (from database) in this category.

$questions = get_questions_category( $this->category );

$count = 0;

// Create the imsmanifest file.

$smarty =& $this->init_smarty();

$this->add_qti_info($questions);

$manifestquestions = $this->objects_to_array($questions);

$manifestid = str_replace(array(':', '/'), array('-', '_'), "question_category_{$this->category->id}---{$CFG->wwwroot}");

$smarty->assign('externalfiles', 1);

$smarty->assign('manifestidentifier', $manifestid);

$smarty->assign('quiztitle', "question_category_{$this->category->id}");

$smarty->assign('quizinfo', "All questions in category {$this->category->id}");

$smarty->assign('questions', $manifestquestions);

$smarty->assign('lang', $this->lang);

$smarty->error_reporting = 99;

$expout = $smarty->fetch('imsmanifest.tpl');

$filepath = $path . '/imsmanifest.xml';

if (empty($expout)) {

print_error('emptyxml', 'question', $continuepath);

}

if (!$fh = fopen($filepath, "w")) {

print_error('cannotopenforwriting', 'question', '', $continuepath);

}

if (!fwrite($fh, $expout)) {

print_error('cannotwriteto', 'question', '', $continuepath);

}

fclose($fh);

$this->xml_entitize($questions);

// Iterate through questions.

foreach ($questions as $question) {

// Do not export hidden questions.

if (!empty($question->hidden)) {

continue;

}

// Do not export random questions.

if ($question->qtype == 'random') {

continue;

}

// used by file api

$contextid = $DB->get_field('question_categories', 'contextid',

array('id' => $question->category));

$question->contextid = $contextid;

// Results are first written into string (and then to a file).

$count++;

$expout = $this->writequestion($question , null, true, $path) . "\n";

$expout = $this->presave_process($expout );

$filepath = $path.'/'.$this->get_assesment_item_id($question) . ".xml";

if (!$fh = fopen($filepath, "w")) {

print_error('cannotopenforwriting', 'question', '', $continuepath);

}

if (!fwrite($fh, $expout)) {

print_error('cannotwriteto', 'question', '', $continuepath);

}

fclose($fh);

}

$this->copy_resources($questions, $this->tempdir);

// Get the list of files in directory.

$filestemp = get_directory_list($path, '', false, true, true);

$files = array();

foreach ($filestemp as $file) {

// Add zip paths and fs paths to all them.

$files[$file] = $path . '/' . $file;

}

// Get the zip packer.

$zippacker = get_file_packer('application/zip');

// Zip files.

$zipfile = $path . '/qti2.zip';

$zippacker->archive_to_pathname($files, $zipfile);

$zipcontent = file_get_contents($zipfile);

// Remove the temporary directory.

fulldelete($path);

return $zipcontent;

}

/**

* exports a quiz (as opposed to exporting a category of questions)

*

* The parent class method was overridden because the IMS export consists of multiple files

*

* @param object $quiz

* @param array $questions - an array of question objects

* @param object $result - if set, contains result of calling quiz_grade_responses()

* @param string $redirect - a URL to redirect to in case of failure

* @param string $submiturl - the URL for the qti player to send the results to (e.g. attempt.php)

* @todo use $result in the ouput

*/

public function export_quiz($course, $quiz, $questions, $result, $redirect, $submiturl = null) {

$this->xml_entitize($course);

$this->xml_entitize($quiz);

$this->xml_entitize($questions);

$this->xml_entitize($result);

$this->xml_entitize($submiturl);

if (!$this->exportpreprocess(0, $course)) { // Do anything before that we need to.

print_error('errorpreprocess', 'question', $redirect);

}

if (!$this->exportprocess_quiz($quiz, $questions, $result, $submiturl, $course)) { // Process the export data.

print_error('errorprocess', 'question', $redirect);

}

if (!$this->exportpostprocess()) { // In case anything needs to be done after.

print_error('errorpostprocess', 'question', $redirect);

}

}

/**

* This function is called to export a quiz (as opposed to exporting a category of questions)

*

* @uses $USER

* @param object $quiz

* @param array $questions - an array of question objects

* @param object $result - if set, contains result of calling quiz_grade_responses()

* @todo use $result in the ouput

*/

public function exportprocess_quiz($quiz, $questions, $result, $submiturl, $course) {

global $USER;

global $CFG;

$gradingmethod = array (1 => 'GRADEHIGHEST',

2 => 'GRADEAVERAGE',

3 => 'ATTEMPTFIRST' ,

4 => 'ATTEMPTLAST');

$questions = $this->quiz_export_prepare_questions($questions, $quiz->id, $course->id, $quiz->shuffleanswers);

$smarty = $this->init_smarty();

$smarty->assign('questions', $questions);

// Quiz level smarty variables.

$manifestid = str_replace(array(':', '/'), array('-', '_'), "quiz{$quiz->id}-{$CFG->wwwroot}");

$smarty->assign('manifestidentifier', $manifestid);

$smarty->assign('submiturl', $submiturl);

$smarty->assign('userid', $USER->id);

$smarty->assign('username', htmlspecialchars($USER->username, ENT_COMPAT, 'UTF-8'));

$smarty->assign('quiz_level_export', 1);

// Assigned specifically so as not to cause problems with category-level export.

$smarty->assign('quiztitle', format_string($quiz->name, true));

$smarty->assign('quiztimeopen', date('Y-m-d\TH:i:s', $quiz->timeopen)); // Ditto.

$smarty->assign('quiztimeclose', date('Y-m-d\TH:i:s', $quiz->timeclose)); // Ditto.

$smarty->assign('grademethod', $gradingmethod[$quiz->grademethod]);

$smarty->assign('quiz', $quiz);

$smarty->assign('course', $course);

$smarty->assign('lang', $this->lang);

$expout = $smarty->fetch('imsmanifest.tpl');

return true;

}

/**

* Prepares questions for quiz export

*

* The questions are changed as follows:

* - the question answers atached to the questions

* - image set to an http reference instead of a file path

* - qti specific info added

* - exporttext added, which contains an xml-formatted qti assesmentItem

*

* @param array $questions - an array of question objects

* @param int $quizid

* @return an array of question arrays

*/

public function quiz_export_prepare_questions($questions, $quizid, $courseid, $shuffleanswers = null) {

global $CFG;

// Add the answers to the questions and format the image property.

foreach ($questions as $key => $question) {

$questions[$key] = get_question_data($question);

$questions[$key]->courseid = $courseid;

$questions[$key]->quizid = $quizid;

}

$this->add_qti_info($questions);

$questions = $this->questions_with_export_info($questions, $shuffleanswers);

$questions = $this->objects_to_array($questions);

return $questions;

}

/**

* calls htmlspecialchars for each string field, to convert, for example, & to &amp;

*

* collections are processed recursively

*

* @param array $collection - an array or object or string

*/

public function xml_entitize(&$collection) {

if (is_array($collection)) {

foreach ($collection as $key => $var) {

if (is_string($var)) {

$collection[$key] = htmlspecialchars($var, ENT_COMPAT, 'UTF-8');

} else if (is_array($var) || is_object($var)) {

$this->xml_entitize($collection[$key]);

}

}

} else if (is_object($collection)) {

$vars = get_object_vars($collection);

foreach ($vars as $key => $var) {

if (is_string($var)) {

$collection->$key = htmlspecialchars($var, ENT_COMPAT, 'UTF-8');

} else if (is_array($var) || is_object($var)) {

$this->xml_entitize($collection->$key);

}

}

} else if (is_string($collection)) {

$collection = htmlspecialchars($collection, ENT_COMPAT, 'UTF-8');

}

}

/**

* adds exporttext property to the questions

*

* Adds the qti export text to the questions

*

* @param array $questions - an array of question objects

* @return an array of question objects

*/

public function questions_with_export_info($questions, $shuffleanswers = null) {

$exportquestions = array();

foreach ($questions as $key => $question) {

$expout = $this->writequestion( $question , $shuffleanswers) . "\n";

$expout = $this->presave_process( $expout );

$key = $this->get_assesment_item_id($question);

$exportquestions[$key] = $question;

$exportquestions[$key]->exporttext = $expout;

}

return $exportquestions;

}

/**

* Creates the export text for a question

*

* @todo handle in-line media (specified in the question/subquestion/answer text) for course-level exports

* @param object $question

* @param bool $shuffleanswers whether or not to shuffle the answers

* @param bool $courselevel whether or not this is a course-level export

* @param string $path provide the path to copy question media files to, if $courselevel == true

* @return string containing export text

*/

public function writequestion($question, $shuffleanswers = null, $courselevel = false, $path = '') {

// Turns question into string.

// Question reflects database fields for general question and specific to type.

global $CFG;

$expout = '';

$question->questiontext = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/questiontext/' . $question->id , $question->questiontext);

if(isset($question->generalfeedback)){

$question->generalfeedback = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/generalfeedback/' . $question->id , $question->generalfeedback);

}

if (!empty($question->options->answers)) {

foreach ($question->options->answers as $key => $answer) {

$question->options->answers[$key]->answer = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/answer/' . $answer->id, $answer->answer);

$question->options->answers[$key]->feedback = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/answerfeedback/' . $answer->id, $answer->feedback);

}

}

if (!empty($question->hints)) {

foreach ($question->hints as $key => $hint) {

$question->hints[$key]->hint = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/hint/' . $hint->id, $hint->hint);

}

}

$hassize = empty($question->mediax) ? 0 : 1;

// All other tags will be stripped from question text.

$allowedtags = '<a><br><b><h1><h2><h3><h4><i><img><li><ol><strong><table><tr><td><th><u><ul><object>';

$smarty =& $this->init_smarty();

$assesmentitemid = $this->get_assesment_item_id($question);

$questionid = "question{$question->id}" . $question->qtype;

$smarty->assign('hassize', $hassize);

$smarty->assign('questionid', $questionid);

$smarty->assign('assessmentitemidentifier', $assesmentitemid);

$smarty->assign('assessmentitemtitle', $question->name);

$smarty->assign('courselevelexport', $courselevel);

$smarty->assign('defaultmark', $question->defaultmark);

if ($question->qtype == 'multianswer') {

$question->questiontext = strip_tags($question->questiontext, $allowedtags . '<intro>');

$smarty->assign('questionText', $this->get_cloze_intro($question->questiontext));

} else {

$smarty->assign('questionText', $question->questiontext);

}

$smarty->assign('question', $question);

// Output depends on question type.

switch($question->qtype) {

case 'truefalse':

$qanswers = $question->options->answers;

$answers[0] = (array)$qanswers[$question->options->trueanswer];

$answers[0]['answer'] = get_string('true', 'qtype_truefalse');

$answers[1] = (array)$qanswers[$question->options->falseanswer];

$answers[1]['answer'] = get_string('false', 'qtype_truefalse');

if (!empty($shuffleanswers)) {

$answers = $this->shuffle_things($answers);

}

if (isset($question->response)) {

$correctresponseid = $question->response[$questionid];

if ($answers[0]['id'] == $correctresponseid) {

$correctresponse = $answers[0];

} else {

$correctresponse = $answers[1];

}

} else {

$correctresponse = '';

}

$smarty->assign('correctresponse', $correctresponse);

$smarty->assign('answers', $answers);

$expout = $smarty->fetch('choice.tpl');

break;

case 'multichoice':

$answers = $this->objects_to_array($question->options->answers);

$correctresponses = $this->get_correct_answers($answers);

$correctcount = count($correctresponses);

$smarty->assign('responsedeclarationcardinality', $question->options->single ? 'single' : 'multiple');

$smarty->assign('operator', $question->options->single ? 'match' : 'member');

$smarty->assign('correctresponses', $correctresponses);

$smarty->assign('answers', $answers);

$smarty->assign('maxChoices', $question->options->single ? '1' : count($answers));

$smarty->assign('shuffle', $question->options->shuffleanswers ? 'true' : 'false');

$smarty->assign('generalfeedback', $question->generalfeedback);

$smarty->assign('correctfeedback', $question->options->correctfeedback);

$smarty->assign('partiallycorrectfeedback', $question->options->partiallycorrectfeedback);

$smarty->assign('incorrectfeedback', $question->options->incorrectfeedback);

$expout = $smarty->fetch('choiceMultiple.tpl');

break;

case 'shortanswer':

$answers = $this->objects_to_array($question->options->answers);

if (!empty($shuffleanswers)) {

$answers = $this->shuffle_things($answers);

}

$correctresponses = $this->get_correct_answers($answers);

$correctcount = count($correctresponses);

$smarty->assign('responsedeclarationcardinality', $correctcount > 1 ? 'multiple' : 'single');

$smarty->assign('correctresponses', $correctresponses);

$smarty->assign('answers', $answers);

$smarty->assign('usecase', $question->options->usecase ? 'true' : 'false');

$expout = $smarty->fetch('textEntry.tpl');

break;

case 'numerical':

$question->instruction = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/question/instruction/' . $question->id , $question->instruction);

$qanswer = array_pop( $question->options->answers );

$smarty->assign('lowerbound', $qanswer->answer - $qanswer->tolerance);

$smarty->assign('upperbound', $qanswer->answer + $qanswer->tolerance);

$smarty->assign('answer', $qanswer->answer);

$expout = $smarty->fetch('numerical.tpl');

break;

case 'match':

if (!empty($question->options->subquestions)) {

foreach ($question->options->subquestions as $key => $subquestion) {

$question->options->subquestions[$key]->questiontext = str_replace('@@PLUGINFILE@@', 'resources/' . $question->id . '/qtype_match/subquestion/' . $subquestion->id, $subquestion->questiontext);

}

}

$subquestions = $this->objects_to_array($question->options->subquestions);

if (!empty($shuffleanswers)) {

$subquestions = $this->shuffle_things($subquestions);

}

$setcount = count($subquestions);

$smarty->assign('setcount', $setcount);

$smarty->assign('matchsets', $subquestions);

$smarty->assign('shuffle', $question->options->shuffleanswers ? 'true' : 'false');

$expout = $smarty->fetch('match.tpl');

break;

case 'description':

$expout = $smarty->fetch('extendedText.tpl');

break;

case 'essay':

$expout = $smarty->fetch('extendedText_simpleEssay.tpl');

break;

// Loss of get_answers() from quiz_embedded_close_qtype class during

// Gustav's refactor breaks multianswer export code badly - one for another day!!

/*

case 'multianswer':

$answers = $this->get_cloze_answers_array($question);

$questions = $this->get_cloze_questions($question, $answers, $allowedtags);

$smarty->assign('cloze_trailing_text_id', CLOZE_TRAILING_TEXT_ID);

$smarty->assign('answers', $answers);

$smarty->assign('questions', $questions);

$expout = $smarty->fetch('composite.tpl');

break; */

default:

$smarty->assign('questionText', "This question type (Unknown: type " . $question->qtype . ") has not yet been implemented");

$expout = $smarty->fetch('notimplemented.tpl');

}

// Run through xml tidy function

// $tidy_expout = $this->indent_xhtml( $expout, ' ' ) . "\n\n";

// return $tidy_expout;

return $expout;

}

/**

* Gets an id to use for a qti assesment item

*

* @param object $question

* @return string containing a qti assesment item id

*/

public function get_assesment_item_id($question) {

return "question{$question->id}";

}

/**

* gets the answers whose grade fraction > 0

*

* @param array $answers

* @return array (0-indexed) containing the answers whose grade fraction > 0

*/

public function get_correct_answers($answers) {

$correctanswers = array();

foreach ($answers as $answer) {

if ($answer['fraction'] > 0) {

$correctanswers[] = $answer;

}

}

return $correctanswers;

}

/**

* gets a new Smarty object, with the template and compile directories set

*

* @return object a smarty object

*/

public function & init_smarty() {

global $CFG;

// Create smarty compile dir in dataroot.

$path = $CFG->dataroot."/smarty_c";

if (!is_dir($path)) {

if (!mkdir($path, $CFG->directorypermissions)) {

print_error('cannotcreatepath', 'question', '', $path);

}

}

$smarty = new Smarty;

$smarty->template_dir = "{$CFG->dirroot}/question/format/qtitwo/templates/claroline";

$smarty->compile_dir = "$path";

return $smarty;

}

/**

* converts an array of objects to an array of arrays (not recursively)

*

* @param array $objectarray

* @return array - an array of answer arrays

*/

public function objects_to_array($objectarray) {

$arrayarray = array();

foreach ($objectarray as $object) {

$arrayarray[] = (array)$object;

}

return $arrayarray;

}

/**

* gets a question's cloze answer objects as arrays containing only arrays and basic data types

*

* @param object $question

* @return array - an array of answer arrays

*/

public function get_cloze_answers_array($question) {

$answers = $this->get_answers($question);

$this->xml_entitize($answers);

foreach ($answers as $answerkey => $answer) {

$answers[$answerkey]->subanswers = $this->objects_to_array($answer->subanswers);

}

return $this->objects_to_array($answers);

}

/**

* gets an array with text and question arrays for the given cloze question

*

* To make smarty processing easier, the returned text and question sub-arrays have an equal number of elements.

* If it is necessary to add a dummy element to the question sub-array, the question will be given an id of CLOZE_TRAILING_TEXT_ID.

*

* @param object $question

* @param array $answers - an array of arrays containing the question's answers

* @param string $allowabletags - tags not to strip out of the question text (e.g. '<i><br>')

* @return array with text and question arrays for the given cloze question

*/

public function get_cloze_questions($question, $answers, $allowabletags) {

$questiontext = strip_tags($question->questiontext, $allowabletags);

if (preg_match_all('/(.*){#([0-9]+)}/U', $questiontext, $matches)) {

// matches[1] contains the text inbetween the question blanks

// matches[2] contains the id of the question blanks (db: question_multianswer.positionkey)

// Find any trailing text after the last {#XX} and add it to the array.

if (preg_match('/.*{#[0-9]+}(.*)$/', $questiontext, $tail)) {

$matches[1][] = $tail[1];

$tailadded = true;

}

$questions['text'] = $matches[1];

$questions['question'] = array();

foreach ($matches[2] as $key => $questionid) {

foreach ($answers as $answer) {

if ($answer['positionkey'] == $questionid) {

$questions['question'][$key] = $answer;

break;

}

}

}

if ($tailadded) {

// To have a matching number of question and text array entries:

$questions['question'][] = array('id' => CLOZE_TRAILING_TEXT_ID, 'answertype' => 'shortanswer');

}

} else {

$questions['text'][0] = $question->questiontext;

$questions['question'][0] = array('id' => CLOZE_TRAILING_TEXT_ID, 'answertype' => 'shortanswer');

}

return $questions;

}

/**

* strips out the <intro>...</intro> section, if any, and returns the text

*

* changes the text object passed to it.

*

* @param string $&text

* @return string the intro text, if there was an intro tag. '' otherwise.

*/

public function get_cloze_intro(&$text) {

if (preg_match('/(.*)?\<intro>(.+)?\<\/intro>(.*)/s', $text, $matches)) {

$text = $matches[1] . $matches[3];

return $matches[2];

} else {

return '';

}

}

/**

* adds qti metadata properties to the questions

*

* The passed array of questions is altered by this function

*

* @param &questions an array of question objects

*/

public function add_qti_info(&$questions) {

foreach ($questions as $key => $question) {

$questions[$key]->qtiinteractiontype = $this->get_qti_interaction_type($question->qtype);

$questions[$key]->qtiscoreable = $this->get_qti_scoreable($question);

$questions[$key]->qtisolutionavailable = $this->get_qti_solution_available($question);

}

}

/**

* returns whether or not a given question is scoreable

*

* @param object $question

* @return bool

*/

public function get_qti_scoreable($question) {

switch ($question->qtype) {

case 'description':

return 'false';

default:

return 'true';

}

}

/**

* returns whether or not a solution is available for a given question

*

* The results are based on whether or not Moodle stores answers for the given question type

*

* @param object $question

* @return bool

*/

public function get_qti_solution_available($question) {

switch($question->qtype) {

case 'truefalse':

return 'true';

case 'multichoice':

return 'true';

case 'shortanswer':

return 'true';

case 'numerical':

return 'true';

case 'match':

return 'true';

case 'description':

return 'false';

case 'multianswer':

return 'true';

default:

return 'true';

}

}

/**

* maps a moodle question type to a qti 2.0 question type

*

* @param string questiontype - the moodle question type

* @return string qti 2.0 question type

*/

public function get_qti_interaction_type($questiontype) {

switch( $questiontype ) {

case 'truefalse':

$name = 'choiceInteraction';

break;

case 'multichoice':

$name = 'choiceInteraction';

break;

case 'shortanswer':

$name = 'textInteraction';

break;

case 'numerical':

$name = 'textInteraction';

break;

case 'match':

$name = 'matchInteraction';

break;

case 'description':

$name = 'extendedTextInteraction';

break;

case 'multianswer':

$name = 'textInteraction';

break;

default:

$name = 'textInteraction';

}

return $name;

}

/**

* returns the given array, shuffled

*

*

* @param array $things

* @return array

*/

public function shuffle_things($things) {

$things = swapshuffle_assoc($things);

$oldthings = $things;

$things = array();

foreach ($oldthings as $key => $value) {

$things[] = $value; // This loses the index key, but doesn't matter.

}

return $things;

}