xesmyd
853 lines
37 KiB
PHP
853 lines
37 KiB
PHP
<?php
|
|
|
|
/* For licensing terms, see /license.txt */
|
|
|
|
namespace moodleexport;
|
|
|
|
use Exception;
|
|
use FillBlanks;
|
|
|
|
/**
|
|
* Class QuizExport.
|
|
*
|
|
* Handles the export of quizzes within a course.
|
|
*/
|
|
class QuizExport extends ActivityExport
|
|
{
|
|
private static $embeddedFileGlobalSeq = 0;
|
|
|
|
/**
|
|
* Export a quiz to the specified directory.
|
|
*
|
|
* @param int $activityId The ID of the quiz.
|
|
* @param string $exportDir The directory where the quiz will be exported.
|
|
* @param int $moduleId The ID of the module.
|
|
* @param int $sectionId The ID of the section.
|
|
*/
|
|
public function export($activityId, $exportDir, $moduleId, $sectionId): void
|
|
{
|
|
$quizDir = $this->prepareActivityDirectory($exportDir, 'quiz', (int) $moduleId);
|
|
$quizData = $this->getData((int) $activityId, (int) $sectionId, (int) $moduleId);
|
|
|
|
if (empty($quizData)) {
|
|
return;
|
|
}
|
|
|
|
$this->createQuizXml($quizData, $quizDir);
|
|
$this->createModuleXml($quizData, $quizDir);
|
|
$this->createGradesXml($quizData, $quizDir);
|
|
$this->createCompletionXml($quizData, $quizDir);
|
|
$this->createCommentsXml($quizData, $quizDir);
|
|
$this->createCompetenciesXml($quizData, $quizDir);
|
|
$this->createFiltersXml($quizData, $quizDir);
|
|
$this->createGradeHistoryXml($quizData, $quizDir);
|
|
$this->createInforefXml($quizData, $quizDir);
|
|
$this->createRolesXml($quizData, $quizDir);
|
|
$this->createCalendarXml($quizData, $quizDir);
|
|
}
|
|
|
|
/**
|
|
* Moodle requires a valid question behaviour.
|
|
*/
|
|
private function sanitizePreferredBehaviour($raw): string
|
|
{
|
|
$behaviour = trim((string) $raw);
|
|
|
|
$allowed = [
|
|
'deferredfeedback',
|
|
'adaptive',
|
|
'adaptivenopenalty',
|
|
'immediatefeedback',
|
|
'interactive',
|
|
'manualgraded',
|
|
'deferredcbm',
|
|
'immediatecbm',
|
|
'interactivecountback',
|
|
];
|
|
|
|
if ($behaviour === '' || !in_array($behaviour, $allowed, true)) {
|
|
return 'deferredfeedback';
|
|
}
|
|
|
|
return $behaviour;
|
|
}
|
|
|
|
/**
|
|
* Normalize an integer-like value.
|
|
*/
|
|
private function sanitizeInt($raw, int $default): int
|
|
{
|
|
if ($raw === null) {
|
|
return $default;
|
|
}
|
|
if (is_string($raw) && trim($raw) === '') {
|
|
return $default;
|
|
}
|
|
return is_numeric($raw) ? (int) $raw : $default;
|
|
}
|
|
|
|
/**
|
|
* Parse a float or return null when missing.
|
|
*/
|
|
private function parseNullableFloat($raw): ?float
|
|
{
|
|
if ($raw === null) {
|
|
return null;
|
|
}
|
|
if (is_string($raw) && trim($raw) === '') {
|
|
return null;
|
|
}
|
|
return is_numeric($raw) ? (float) $raw : null;
|
|
}
|
|
|
|
/**
|
|
* Moodle quiz navmethod accepted values.
|
|
*/
|
|
private function sanitizeNavMethod($raw): string
|
|
{
|
|
$v = trim((string) $raw);
|
|
return in_array($v, ['free', 'sequential'], true) ? $v : 'free';
|
|
}
|
|
|
|
/**
|
|
* Build a stable question category id per exported quiz occurrence.
|
|
*/
|
|
private function buildQuizQuestionCategoryId(int $moduleId): int
|
|
{
|
|
return 1000000000 + max(1, $moduleId);
|
|
}
|
|
|
|
/**
|
|
* Retrieves the quiz data.
|
|
*/
|
|
public function getData(int $quizId, int $sectionId, ?int $moduleId = null): array
|
|
{
|
|
$quizResources = $this->course->resources[RESOURCE_QUIZ] ?? [];
|
|
|
|
foreach ($quizResources as $quiz) {
|
|
if ($quiz->obj->iid == -1) {
|
|
continue;
|
|
}
|
|
|
|
if ((int) $quiz->obj->iid !== $quizId) {
|
|
continue;
|
|
}
|
|
|
|
$courseCode = $this->course->info['code'] ?? ($this->course->code ?? '');
|
|
$courseInfo = api_get_course_info($courseCode);
|
|
$courseRealId = (int) ($courseInfo['real_id'] ?? 0);
|
|
|
|
$contextid = $this->buildQuestionBankContextId($courseRealId);
|
|
|
|
$effectiveModuleId = (int) ($moduleId ?? ($quiz->obj->iid ?? 0));
|
|
if ($effectiveModuleId <= 0) {
|
|
$effectiveModuleId = (int) ($quiz->obj->iid ?? 0);
|
|
}
|
|
|
|
$questionCategoryId = $this->buildQuizQuestionCategoryId($effectiveModuleId);
|
|
|
|
$name = (string) ($quiz->obj->title ?? '');
|
|
if ($sectionId > 0) {
|
|
$name = $this->lpItemTitle($sectionId, RESOURCE_QUIZ, $quizId, $name);
|
|
}
|
|
$name = $this->sanitizeMoodleActivityName($name, 255);
|
|
|
|
$adminData = MoodleExport::getAdminUserData();
|
|
$adminId = (int) ($adminData['id'] ?? 1);
|
|
|
|
$quizFiles = [];
|
|
$questions = $this->getQuestionsForQuiz(
|
|
$quizId,
|
|
$questionCategoryId,
|
|
$contextid,
|
|
$courseInfo,
|
|
$adminId,
|
|
$quizFiles
|
|
);
|
|
|
|
$computedSumgrades = 0.0;
|
|
foreach ($questions as $q) {
|
|
$computedSumgrades += (float) ($q['maxmark'] ?? 0.0);
|
|
}
|
|
|
|
$rawSumgrades = $this->parseNullableFloat($quiz->obj->sumgrades ?? null);
|
|
$rawGrade = $this->parseNullableFloat($quiz->obj->grade ?? null);
|
|
|
|
$sumgrades = $rawSumgrades !== null ? $rawSumgrades : $computedSumgrades;
|
|
$grade = $rawGrade !== null ? $rawGrade : ($sumgrades > 0 ? $sumgrades : 0.0);
|
|
|
|
return [
|
|
'id' => (int) ($quiz->obj->iid ?? 0),
|
|
'name' => $name,
|
|
'intro' => (string) ($quiz->obj->description ?? ''),
|
|
'timeopen' => $this->sanitizeInt($quiz->obj->start_time ?? null, 0),
|
|
'timeclose' => $this->sanitizeInt($quiz->obj->end_time ?? null, 0),
|
|
'timelimit' => $this->sanitizeInt($quiz->obj->timelimit ?? null, 0),
|
|
'grademethod' => $this->sanitizeInt($quiz->obj->grademethod ?? null, 1),
|
|
'decimalpoints' => $this->sanitizeInt($quiz->obj->decimalpoints ?? null, 2),
|
|
'sumgrades' => $sumgrades,
|
|
'grade' => $grade,
|
|
'questionsperpage' => $this->sanitizeInt($quiz->obj->questionsperpage ?? null, 1),
|
|
'preferredbehaviour' => $this->sanitizePreferredBehaviour($quiz->obj->preferredbehaviour ?? null),
|
|
'shuffleanswers' => $this->sanitizeInt($quiz->obj->shuffleanswers ?? null, 1),
|
|
'navmethod' => $this->sanitizeNavMethod($quiz->obj->navmethod ?? null),
|
|
'question_category_id' => $questionCategoryId,
|
|
'questions' => $questions,
|
|
'files' => $quizFiles,
|
|
'feedbacks' => $this->getFeedbacksForQuiz($quizId),
|
|
'sectionid' => $sectionId,
|
|
'moduleid' => $effectiveModuleId,
|
|
'modulename' => 'quiz',
|
|
'contextid' => $contextid,
|
|
'courseid' => $courseRealId,
|
|
'overduehandling' => (string) ($quiz->obj->overduehandling ?? 'autosubmit'),
|
|
'graceperiod' => $this->sanitizeInt($quiz->obj->graceperiod ?? null, 0),
|
|
'canredoquestions' => $this->sanitizeInt($quiz->obj->canredoquestions ?? null, 0),
|
|
'attempts_number' => $this->sanitizeInt($quiz->obj->attempts_number ?? null, 0),
|
|
'attemptonlast' => $this->sanitizeInt($quiz->obj->attemptonlast ?? null, 0),
|
|
'questiondecimalpoints' => $this->sanitizeInt($quiz->obj->questiondecimalpoints ?? null, 2),
|
|
'reviewattempt' => $this->sanitizeInt($quiz->obj->reviewattempt ?? null, 0),
|
|
'reviewcorrectness' => $this->sanitizeInt($quiz->obj->reviewcorrectness ?? null, 0),
|
|
'reviewmarks' => $this->sanitizeInt($quiz->obj->reviewmarks ?? null, 0),
|
|
'reviewspecificfeedback' => $this->sanitizeInt($quiz->obj->reviewspecificfeedback ?? null, 0),
|
|
'reviewgeneralfeedback' => $this->sanitizeInt($quiz->obj->reviewgeneralfeedback ?? null, 0),
|
|
'reviewrightanswer' => $this->sanitizeInt($quiz->obj->reviewrightanswer ?? null, 0),
|
|
'reviewoverallfeedback' => $this->sanitizeInt($quiz->obj->reviewoverallfeedback ?? null, 0),
|
|
'timecreated' => $this->sanitizeInt($quiz->obj->insert_date ?? null, time()),
|
|
'timemodified' => $this->sanitizeInt($quiz->obj->lastedit_date ?? null, time()),
|
|
'password' => (string) ($quiz->obj->password ?? ''),
|
|
'subnet' => (string) ($quiz->obj->subnet ?? ''),
|
|
'browsersecurity' => (string) ($quiz->obj->browsersecurity ?? '-'),
|
|
'delay1' => $this->sanitizeInt($quiz->obj->delay1 ?? null, 0),
|
|
'delay2' => $this->sanitizeInt($quiz->obj->delay2 ?? null, 0),
|
|
'showuserpicture' => $this->sanitizeInt($quiz->obj->showuserpicture ?? null, 0),
|
|
'showblocks' => $this->sanitizeInt($quiz->obj->showblocks ?? null, 0),
|
|
'completionattemptsexhausted' => $this->sanitizeInt($quiz->obj->completionattemptsexhausted ?? null, 0),
|
|
'completionpass' => $this->sanitizeInt($quiz->obj->completionpass ?? null, 0),
|
|
'completionminattempts' => $this->sanitizeInt($quiz->obj->completionminattempts ?? null, 0),
|
|
'allowofflineattempts' => $this->sanitizeInt($quiz->obj->allowofflineattempts ?? null, 0),
|
|
'users' => [],
|
|
];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Exports a question in XML format.
|
|
*/
|
|
public function exportQuestion(array $question): string
|
|
{
|
|
$questionText = (string) ($question['questiontext'] ?? 'No question text');
|
|
$questionName = $this->sanitizeQuestionName($questionText, 255);
|
|
|
|
$xmlContent = ' <question id="'.($question['id'] ?? '0').'">'.PHP_EOL;
|
|
$xmlContent .= ' <parent>0</parent>'.PHP_EOL;
|
|
$xmlContent .= ' <name>'.htmlspecialchars($questionName).'</name>'.PHP_EOL;
|
|
$xmlContent .= ' <questiontext>'.htmlspecialchars($questionText).'</questiontext>'.PHP_EOL;
|
|
$xmlContent .= ' <questiontextformat>1</questiontextformat>'.PHP_EOL;
|
|
$xmlContent .= ' <generalfeedback></generalfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <generalfeedbackformat>1</generalfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <defaultmark>'.($question['maxmark'] ?? '0').'</defaultmark>'.PHP_EOL;
|
|
$xmlContent .= ' <penalty>0.3333333</penalty>'.PHP_EOL;
|
|
$xmlContent .= ' <qtype>'.htmlspecialchars((string) str_replace('_nosingle', '', $question['qtype'] ?? 'unknown')).'</qtype>'.PHP_EOL;
|
|
$xmlContent .= ' <length>1</length>'.PHP_EOL;
|
|
$xmlContent .= ' <stamp>moodle+'.time().'+QUESTIONSTAMP</stamp>'.PHP_EOL;
|
|
$xmlContent .= ' <version>moodle+'.time().'+VERSIONSTAMP</version>'.PHP_EOL;
|
|
$xmlContent .= ' <hidden>0</hidden>'.PHP_EOL;
|
|
$xmlContent .= ' <timecreated>'.time().'</timecreated>'.PHP_EOL;
|
|
$xmlContent .= ' <timemodified>'.time().'</timemodified>'.PHP_EOL;
|
|
$xmlContent .= ' <createdby>2</createdby>'.PHP_EOL;
|
|
$xmlContent .= ' <modifiedby>2</modifiedby>'.PHP_EOL;
|
|
|
|
switch ($question['qtype']) {
|
|
case 'multichoice':
|
|
$xmlContent .= $this->exportMultichoiceQuestion($question);
|
|
break;
|
|
case 'multichoice_nosingle':
|
|
$xmlContent .= $this->exportMultichoiceNosingleQuestion($question);
|
|
break;
|
|
case 'truefalse':
|
|
$xmlContent .= $this->exportTrueFalseQuestion($question);
|
|
break;
|
|
case 'shortanswer':
|
|
$xmlContent .= $this->exportShortAnswerQuestion($question);
|
|
break;
|
|
case 'match':
|
|
$xmlContent .= $this->exportMatchQuestion($question);
|
|
break;
|
|
}
|
|
|
|
$xmlContent .= ' </question>'.PHP_EOL;
|
|
|
|
return $xmlContent;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the questions for a specific quiz.
|
|
*/
|
|
private function getQuestionsForQuiz(
|
|
int $quizId,
|
|
int $questionCategoryId,
|
|
int $contextId,
|
|
array $courseInfo,
|
|
int $adminId,
|
|
array &$quizFiles
|
|
): array {
|
|
$questions = [];
|
|
$quizResources = $this->course->resources[RESOURCE_QUIZQUESTION] ?? [];
|
|
|
|
foreach ($quizResources as $questionId => $questionData) {
|
|
if (!in_array($questionId, $this->course->resources[RESOURCE_QUIZ][$quizId]->obj->question_ids)) {
|
|
continue;
|
|
}
|
|
|
|
$qRes = $this->extractQuestionEmbeddedFilesAndNormalizeContent(
|
|
(string) ($questionData->question ?? ''),
|
|
$contextId,
|
|
'questiontext',
|
|
(int) $questionData->source_id,
|
|
'',
|
|
$courseInfo,
|
|
$adminId
|
|
);
|
|
|
|
if (!empty($qRes['files'])) {
|
|
$quizFiles = array_merge($quizFiles, $qRes['files']);
|
|
}
|
|
|
|
$answers = $this->getAnswersForQuestion(
|
|
(int) $questionData->source_id,
|
|
$contextId,
|
|
$courseInfo,
|
|
$adminId,
|
|
$quizFiles
|
|
);
|
|
|
|
$mappedType = $this->mapQuestionType((string) $questionData->quiz_type);
|
|
|
|
if ($mappedType === 'unknown') {
|
|
continue;
|
|
}
|
|
|
|
$questions[] = [
|
|
'id' => (int) $questionData->source_id,
|
|
'questiontext' => $qRes['content'],
|
|
'qtype' => $mappedType,
|
|
'questioncategoryid' => $questionCategoryId,
|
|
'answers' => $answers,
|
|
'maxmark' => $questionData->ponderation ?? 1,
|
|
];
|
|
}
|
|
|
|
return $questions;
|
|
}
|
|
|
|
/**
|
|
* Maps the quiz type code to a descriptive string.
|
|
*/
|
|
private function mapQuestionType(string $quizType): string
|
|
{
|
|
switch ($quizType) {
|
|
case UNIQUE_ANSWER:
|
|
return 'multichoice';
|
|
case MULTIPLE_ANSWER:
|
|
return 'multichoice_nosingle';
|
|
case FILL_IN_BLANKS:
|
|
return 'match';
|
|
case FREE_ANSWER:
|
|
return 'shortanswer';
|
|
case CALCULATED_ANSWER:
|
|
return 'calculated';
|
|
case UPLOAD_ANSWER:
|
|
return 'fileupload';
|
|
default:
|
|
return 'unknown';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves the answers for a specific question ID.
|
|
*/
|
|
private function getAnswersForQuestion(
|
|
int $questionId,
|
|
int $contextId,
|
|
array $courseInfo,
|
|
int $adminId,
|
|
array &$collectedFiles
|
|
): array {
|
|
$answers = [];
|
|
$quizResources = $this->course->resources[RESOURCE_QUIZQUESTION] ?? [];
|
|
|
|
foreach ($quizResources as $questionData) {
|
|
if ((int) $questionData->source_id !== $questionId) {
|
|
continue;
|
|
}
|
|
|
|
$answerIndex = 0;
|
|
|
|
foreach ($questionData->answers as $answer) {
|
|
$answerIndex++;
|
|
|
|
$answerId = $this->buildStableQuestionAnswerId($questionId, $answerIndex);
|
|
$rawText = (string) ($answer['answer'] ?? '');
|
|
|
|
$res = $this->extractQuestionEmbeddedFilesAndNormalizeContent(
|
|
$rawText,
|
|
$contextId,
|
|
'answer',
|
|
$answerId,
|
|
'',
|
|
$courseInfo,
|
|
$adminId
|
|
);
|
|
|
|
if (!empty($res['files'])) {
|
|
$collectedFiles = array_merge($collectedFiles, $res['files']);
|
|
}
|
|
|
|
$answers[] = [
|
|
'id' => $answerId,
|
|
'text' => $res['content'],
|
|
'fraction' => (($answer['correct'] ?? '0') == '1') ? 100 : 0,
|
|
'feedback' => (string) ($answer['comment'] ?? ''),
|
|
];
|
|
}
|
|
}
|
|
|
|
return $answers;
|
|
}
|
|
|
|
/**
|
|
* Retrieves feedbacks for a specific quiz.
|
|
*/
|
|
private function getFeedbacksForQuiz(int $quizId): array
|
|
{
|
|
$feedbacks = [];
|
|
$quizResources = $this->course->resources[RESOURCE_QUIZ] ?? [];
|
|
|
|
foreach ($quizResources as $quiz) {
|
|
if ((int) $quiz->obj->iid === $quizId) {
|
|
$feedbacks[] = [
|
|
'feedbacktext' => (string) ($quiz->obj->description ?? ''),
|
|
'mingrade' => 0.00000,
|
|
'maxgrade' => $quiz->obj->grade ?? 10.00000,
|
|
];
|
|
}
|
|
}
|
|
|
|
return $feedbacks;
|
|
}
|
|
|
|
/**
|
|
* Creates the quiz.xml file.
|
|
*/
|
|
private function createQuizXml(array $quizData, string $destinationDir): void
|
|
{
|
|
$preferredBehaviour = trim((string) ($quizData['preferredbehaviour'] ?? ''));
|
|
if ($preferredBehaviour === '') {
|
|
$preferredBehaviour = 'deferredfeedback';
|
|
}
|
|
|
|
$gradeMethod = (int) ($quizData['grademethod'] ?? 1);
|
|
$decimalPoints = (int) ($quizData['decimalpoints'] ?? 2);
|
|
$questionsPerPage = (int) ($quizData['questionsperpage'] ?? 1);
|
|
$navMethod = (string) ($quizData['navmethod'] ?? 'free');
|
|
$shuffleAnswers = (int) ($quizData['shuffleanswers'] ?? 1);
|
|
$sumGrades = (float) ($quizData['sumgrades'] ?? 0.0);
|
|
$grade = (float) ($quizData['grade'] ?? 0.0);
|
|
|
|
$xmlContent = '<?xml version="1.0" encoding="UTF-8"?>'.PHP_EOL;
|
|
$xmlContent .= '<activity id="'.$quizData['id'].'" moduleid="'.$quizData['moduleid'].'" modulename="quiz" contextid="'.$quizData['contextid'].'">'.PHP_EOL;
|
|
$xmlContent .= ' <quiz id="'.$quizData['id'].'">'.PHP_EOL;
|
|
$xmlContent .= ' <name>'.htmlspecialchars((string) $quizData['name']).'</name>'.PHP_EOL;
|
|
$xmlContent .= ' <intro>'.htmlspecialchars((string) $quizData['intro']).'</intro>'.PHP_EOL;
|
|
$xmlContent .= ' <introformat>1</introformat>'.PHP_EOL;
|
|
$xmlContent .= ' <timeopen>'.($quizData['timeopen'] ?? 0).'</timeopen>'.PHP_EOL;
|
|
$xmlContent .= ' <timeclose>'.($quizData['timeclose'] ?? 0).'</timeclose>'.PHP_EOL;
|
|
$xmlContent .= ' <timelimit>'.($quizData['timelimit'] ?? 0).'</timelimit>'.PHP_EOL;
|
|
$xmlContent .= ' <overduehandling>'.($quizData['overduehandling'] ?? 'autosubmit').'</overduehandling>'.PHP_EOL;
|
|
$xmlContent .= ' <graceperiod>'.($quizData['graceperiod'] ?? 0).'</graceperiod>'.PHP_EOL;
|
|
$xmlContent .= ' <preferredbehaviour>'.htmlspecialchars($preferredBehaviour).'</preferredbehaviour>'.PHP_EOL;
|
|
$xmlContent .= ' <canredoquestions>'.($quizData['canredoquestions'] ?? 0).'</canredoquestions>'.PHP_EOL;
|
|
$xmlContent .= ' <attempts_number>'.($quizData['attempts_number'] ?? 0).'</attempts_number>'.PHP_EOL;
|
|
$xmlContent .= ' <attemptonlast>'.($quizData['attemptonlast'] ?? 0).'</attemptonlast>'.PHP_EOL;
|
|
$xmlContent .= ' <grademethod>'.$gradeMethod.'</grademethod>'.PHP_EOL;
|
|
$xmlContent .= ' <decimalpoints>'.$decimalPoints.'</decimalpoints>'.PHP_EOL;
|
|
$xmlContent .= ' <questiondecimalpoints>'.($quizData['questiondecimalpoints'] ?? -1).'</questiondecimalpoints>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewattempt>'.($quizData['reviewattempt'] ?? 69888).'</reviewattempt>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewcorrectness>'.($quizData['reviewcorrectness'] ?? 4352).'</reviewcorrectness>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewmarks>'.($quizData['reviewmarks'] ?? 4352).'</reviewmarks>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewspecificfeedback>'.($quizData['reviewspecificfeedback'] ?? 4352).'</reviewspecificfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewgeneralfeedback>'.($quizData['reviewgeneralfeedback'] ?? 4352).'</reviewgeneralfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewrightanswer>'.($quizData['reviewrightanswer'] ?? 4352).'</reviewrightanswer>'.PHP_EOL;
|
|
$xmlContent .= ' <reviewoverallfeedback>'.($quizData['reviewoverallfeedback'] ?? 4352).'</reviewoverallfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <questionsperpage>'.$questionsPerPage.'</questionsperpage>'.PHP_EOL;
|
|
$xmlContent .= ' <navmethod>'.htmlspecialchars($navMethod).'</navmethod>'.PHP_EOL;
|
|
$xmlContent .= ' <shuffleanswers>'.$shuffleAnswers.'</shuffleanswers>'.PHP_EOL;
|
|
$xmlContent .= ' <sumgrades>'.$sumGrades.'</sumgrades>'.PHP_EOL;
|
|
$xmlContent .= ' <grade>'.$grade.'</grade>'.PHP_EOL;
|
|
$xmlContent .= ' <timecreated>'.($quizData['timecreated'] ?? time()).'</timecreated>'.PHP_EOL;
|
|
$xmlContent .= ' <timemodified>'.($quizData['timemodified'] ?? time()).'</timemodified>'.PHP_EOL;
|
|
$xmlContent .= ' <password>'.(isset($quizData['password']) ? htmlspecialchars((string) $quizData['password']) : '').'</password>'.PHP_EOL;
|
|
$xmlContent .= ' <subnet>'.(isset($quizData['subnet']) ? htmlspecialchars((string) $quizData['subnet']) : '').'</subnet>'.PHP_EOL;
|
|
$xmlContent .= ' <browsersecurity>'.(isset($quizData['browsersecurity']) ? htmlspecialchars((string) $quizData['browsersecurity']) : '-').'</browsersecurity>'.PHP_EOL;
|
|
$xmlContent .= ' <delay1>'.($quizData['delay1'] ?? 0).'</delay1>'.PHP_EOL;
|
|
$xmlContent .= ' <delay2>'.($quizData['delay2'] ?? 0).'</delay2>'.PHP_EOL;
|
|
$xmlContent .= ' <showuserpicture>'.($quizData['showuserpicture'] ?? 0).'</showuserpicture>'.PHP_EOL;
|
|
$xmlContent .= ' <showblocks>'.($quizData['showblocks'] ?? 0).'</showblocks>'.PHP_EOL;
|
|
$xmlContent .= ' <completionattemptsexhausted>'.($quizData['completionattemptsexhausted'] ?? 0).'</completionattemptsexhausted>'.PHP_EOL;
|
|
$xmlContent .= ' <completionpass>'.($quizData['completionpass'] ?? 0).'</completionpass>'.PHP_EOL;
|
|
$xmlContent .= ' <completionminattempts>'.($quizData['completionminattempts'] ?? 0).'</completionminattempts>'.PHP_EOL;
|
|
$xmlContent .= ' <allowofflineattempts>'.($quizData['allowofflineattempts'] ?? 0).'</allowofflineattempts>'.PHP_EOL;
|
|
$xmlContent .= ' <subplugin_quizaccess_seb_quiz>'.PHP_EOL;
|
|
$xmlContent .= ' </subplugin_quizaccess_seb_quiz>'.PHP_EOL;
|
|
$xmlContent .= ' <question_instances>'.PHP_EOL;
|
|
$slotIndex = 1;
|
|
foreach ($quizData['questions'] as $question) {
|
|
$xmlContent .= ' <question_instance id="'.$question['id'].'">'.PHP_EOL;
|
|
$xmlContent .= ' <slot>'.$slotIndex.'</slot>'.PHP_EOL;
|
|
$xmlContent .= ' <page>1</page>'.PHP_EOL;
|
|
$xmlContent .= ' <requireprevious>0</requireprevious>'.PHP_EOL;
|
|
$xmlContent .= ' <questionid>'.$question['id'].'</questionid>'.PHP_EOL;
|
|
$xmlContent .= ' <questioncategoryid>'.$question['questioncategoryid'].'</questioncategoryid>'.PHP_EOL;
|
|
$xmlContent .= ' <includingsubcategories>$@NULL@$</includingsubcategories>'.PHP_EOL;
|
|
$xmlContent .= ' <maxmark>'.$question['maxmark'].'</maxmark>'.PHP_EOL;
|
|
$xmlContent .= ' </question_instance>'.PHP_EOL;
|
|
$slotIndex++;
|
|
}
|
|
$xmlContent .= ' </question_instances>'.PHP_EOL;
|
|
$xmlContent .= ' <sections>'.PHP_EOL;
|
|
$xmlContent .= ' <section id="'.$quizData['id'].'">'.PHP_EOL;
|
|
$xmlContent .= ' <firstslot>1</firstslot>'.PHP_EOL;
|
|
$xmlContent .= ' <shufflequestions>0</shufflequestions>'.PHP_EOL;
|
|
$xmlContent .= ' </section>'.PHP_EOL;
|
|
$xmlContent .= ' </sections>'.PHP_EOL;
|
|
$xmlContent .= ' <feedbacks>'.PHP_EOL;
|
|
foreach ($quizData['feedbacks'] as $feedback) {
|
|
$xmlContent .= ' <feedback id="'.$quizData['id'].'">'.PHP_EOL;
|
|
$xmlContent .= ' <feedbacktext>'.htmlspecialchars((string) $feedback['feedbacktext']).'</feedbacktext>'.PHP_EOL;
|
|
$xmlContent .= ' <feedbacktextformat>1</feedbacktextformat>'.PHP_EOL;
|
|
$xmlContent .= ' <mingrade>'.$feedback['mingrade'].'</mingrade>'.PHP_EOL;
|
|
$xmlContent .= ' <maxgrade>'.$feedback['maxgrade'].'</maxgrade>'.PHP_EOL;
|
|
$xmlContent .= ' </feedback>'.PHP_EOL;
|
|
}
|
|
$xmlContent .= ' </feedbacks>'.PHP_EOL;
|
|
$xmlContent .= ' <overrides>'.PHP_EOL.' </overrides>'.PHP_EOL;
|
|
$xmlContent .= ' <grades>'.PHP_EOL.' </grades>'.PHP_EOL;
|
|
$xmlContent .= ' <attempts>'.PHP_EOL.' </attempts>'.PHP_EOL;
|
|
$xmlContent .= ' </quiz>'.PHP_EOL;
|
|
$xmlContent .= '</activity>'.PHP_EOL;
|
|
|
|
$xmlFile = $destinationDir.'/quiz.xml';
|
|
if (file_put_contents($xmlFile, $xmlContent) === false) {
|
|
throw new Exception(get_lang('ErrorCreatingQuizXml'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Exports a multiple-choice question in XML format.
|
|
*/
|
|
private function exportMultichoiceQuestion(array $question): string
|
|
{
|
|
$xmlContent = ' <plugin_qtype_multichoice_question>'.PHP_EOL;
|
|
$xmlContent .= ' <answers>'.PHP_EOL;
|
|
foreach ($question['answers'] as $answer) {
|
|
$xmlContent .= $this->exportAnswer($answer);
|
|
}
|
|
$xmlContent .= ' </answers>'.PHP_EOL;
|
|
$xmlContent .= ' <multichoice id="'.($question['id'] ?? '0').'">'.PHP_EOL;
|
|
$xmlContent .= ' <layout>0</layout>'.PHP_EOL;
|
|
$xmlContent .= ' <single>1</single>'.PHP_EOL;
|
|
$xmlContent .= ' <shuffleanswers>1</shuffleanswers>'.PHP_EOL;
|
|
$xmlContent .= ' <correctfeedback>Your answer is correct.</correctfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <correctfeedbackformat>1</correctfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <partiallycorrectfeedback>Your answer is partially correct.</partiallycorrectfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <partiallycorrectfeedbackformat>1</partiallycorrectfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <incorrectfeedback>Your answer is incorrect.</incorrectfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <incorrectfeedbackformat>1</incorrectfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <answernumbering>abc</answernumbering>'.PHP_EOL;
|
|
$xmlContent .= ' <shownumcorrect>1</shownumcorrect>'.PHP_EOL;
|
|
$xmlContent .= ' </multichoice>'.PHP_EOL;
|
|
$xmlContent .= ' </plugin_qtype_multichoice_question>'.PHP_EOL;
|
|
|
|
return $xmlContent;
|
|
}
|
|
|
|
/**
|
|
* Exports a multiple-choice question with single=0 in XML format.
|
|
*/
|
|
private function exportMultichoiceNosingleQuestion(array $question): string
|
|
{
|
|
return str_replace('<single>1</single>', '<single>0</single>', $this->exportMultichoiceQuestion($question));
|
|
}
|
|
|
|
/**
|
|
* Exports a true/false question in XML format.
|
|
*/
|
|
private function exportTrueFalseQuestion(array $question): string
|
|
{
|
|
$xmlContent = ' <plugin_qtype_truefalse_question>'.PHP_EOL;
|
|
$xmlContent .= ' <answers>'.PHP_EOL;
|
|
foreach ($question['answers'] as $answer) {
|
|
$xmlContent .= $this->exportAnswer($answer);
|
|
}
|
|
$xmlContent .= ' </answers>'.PHP_EOL;
|
|
$xmlContent .= ' <truefalse id="'.($question['id'] ?? '0').'">'.PHP_EOL;
|
|
$trueId = $question['answers'][0]['id'] ?? 0;
|
|
$falseId = $question['answers'][1]['id'] ?? 0;
|
|
$xmlContent .= ' <trueanswer>'.$trueId.'</trueanswer>'.PHP_EOL;
|
|
$xmlContent .= ' <falseanswer>'.$falseId.'</falseanswer>'.PHP_EOL;
|
|
$xmlContent .= ' </truefalse>'.PHP_EOL;
|
|
$xmlContent .= ' </plugin_qtype_truefalse_question>'.PHP_EOL;
|
|
|
|
return $xmlContent;
|
|
}
|
|
|
|
/**
|
|
* Exports a short answer question in XML format.
|
|
*/
|
|
private function exportShortAnswerQuestion(array $question): string
|
|
{
|
|
$xmlContent = ' <plugin_qtype_shortanswer_question>'.PHP_EOL;
|
|
$xmlContent .= ' <answers>'.PHP_EOL;
|
|
foreach ($question['answers'] as $answer) {
|
|
$xmlContent .= $this->exportAnswer($answer);
|
|
}
|
|
$xmlContent .= ' </answers>'.PHP_EOL;
|
|
$xmlContent .= ' <shortanswer id="'.($question['id'] ?? '0').'">'.PHP_EOL;
|
|
$xmlContent .= ' <usecase>0</usecase>'.PHP_EOL;
|
|
$xmlContent .= ' </shortanswer>'.PHP_EOL;
|
|
$xmlContent .= ' </plugin_qtype_shortanswer_question>'.PHP_EOL;
|
|
|
|
return $xmlContent;
|
|
}
|
|
|
|
/**
|
|
* Exports a matching question in XML format.
|
|
*/
|
|
private function exportMatchQuestion(array $question): string
|
|
{
|
|
$xmlContent = ' <plugin_qtype_match_question>'.PHP_EOL;
|
|
$xmlContent .= ' <matchoptions id="'.htmlspecialchars((string) ($question['id'] ?? '0')).'">'.PHP_EOL;
|
|
$xmlContent .= ' <shuffleanswers>1</shuffleanswers>'.PHP_EOL;
|
|
$xmlContent .= ' <correctfeedback>'.htmlspecialchars((string) ($question['correctfeedback'] ?? '')).'</correctfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <correctfeedbackformat>0</correctfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <partiallycorrectfeedback>'.htmlspecialchars((string) ($question['partiallycorrectfeedback'] ?? '')).'</partiallycorrectfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <partiallycorrectfeedbackformat>0</partiallycorrectfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <incorrectfeedback>'.htmlspecialchars((string) ($question['incorrectfeedback'] ?? '')).'</incorrectfeedback>'.PHP_EOL;
|
|
$xmlContent .= ' <incorrectfeedbackformat>0</incorrectfeedbackformat>'.PHP_EOL;
|
|
$xmlContent .= ' <shownumcorrect>0</shownumcorrect>'.PHP_EOL;
|
|
$xmlContent .= ' </matchoptions>'.PHP_EOL;
|
|
$xmlContent .= ' <matches>'.PHP_EOL;
|
|
|
|
$res = FillBlanks::getAnswerInfo($question['answers'][0]['text']);
|
|
$words = $res['words'];
|
|
$common_words = $res['common_words'];
|
|
|
|
for ($i = 0; $i < count($common_words); $i++) {
|
|
$answer = htmlspecialchars(trim(strip_tags($common_words[$i])));
|
|
if (!empty(trim($answer))) {
|
|
$xmlContent .= ' <match id="'.($i + 1).'">'.PHP_EOL;
|
|
$xmlContent .= ' <questiontext>'.$answer.'</questiontext>'.PHP_EOL;
|
|
$xmlContent .= ' <questiontextformat>0</questiontextformat>'.PHP_EOL;
|
|
$xmlContent .= ' <answertext>'.htmlspecialchars(explode('|', $words[$i])[0]).'</answertext>'.PHP_EOL;
|
|
$xmlContent .= ' </match>'.PHP_EOL;
|
|
}
|
|
}
|
|
|
|
$xmlContent .= ' </matches>'.PHP_EOL;
|
|
$xmlContent .= ' </plugin_qtype_match_question>'.PHP_EOL;
|
|
|
|
return $xmlContent;
|
|
}
|
|
|
|
/**
|
|
* Exports an answer in XML format.
|
|
*/
|
|
private function exportAnswer(array $answer): string
|
|
{
|
|
return ' <answer id="'.($answer['id'] ?? '0').'">'.PHP_EOL.
|
|
' <answertext>'.htmlspecialchars((string) ($answer['text'] ?? 'No answer text')).'</answertext>'.PHP_EOL.
|
|
' <answerformat>1</answerformat>'.PHP_EOL.
|
|
' <fraction>'.($answer['fraction'] ?? '0').'</fraction>'.PHP_EOL.
|
|
' <feedback>'.htmlspecialchars((string) ($answer['feedback'] ?? '')).'</feedback>'.PHP_EOL.
|
|
' <feedbackformat>1</feedbackformat>'.PHP_EOL.
|
|
' </answer>'.PHP_EOL;
|
|
}
|
|
|
|
private function ensureTrailingSlash(string $path): string
|
|
{
|
|
if ($path === '' || $path === '.' || $path === '/') {
|
|
return '/';
|
|
}
|
|
$path = preg_replace('#/+#', '/', $path);
|
|
return rtrim($path, '/').'/';
|
|
}
|
|
|
|
private function buildQuestionEmbeddedFileId(int $baseId, int $sequence): int
|
|
{
|
|
self::$embeddedFileGlobalSeq++;
|
|
|
|
return 1300000000 + self::$embeddedFileGlobalSeq;
|
|
}
|
|
|
|
/**
|
|
* Extract embedded /document/* images from HTML and rewrite src to @@PLUGINFILE@@.
|
|
*
|
|
* @return array{content:string, files:array<int,array<string,mixed>>}
|
|
*/
|
|
private function extractQuestionEmbeddedFilesAndNormalizeContent(
|
|
string $html,
|
|
int $contextId,
|
|
string $fileArea,
|
|
int $itemId,
|
|
string $prefix,
|
|
array $courseInfo,
|
|
int $adminId
|
|
): array {
|
|
if ($html === '') {
|
|
return ['content' => '', 'files' => []];
|
|
}
|
|
|
|
$fileExport = new FileExport($this->course);
|
|
$files = [];
|
|
$seenDocIds = [];
|
|
$sequence = 0;
|
|
|
|
$normalizedHtml = preg_replace_callback(
|
|
'#<img[^>]+src=["\'](?<url>[^"\']+)["\']#i',
|
|
function ($match) use (
|
|
$contextId,
|
|
$fileArea,
|
|
$itemId,
|
|
$courseInfo,
|
|
$adminId,
|
|
$fileExport,
|
|
&$files,
|
|
&$seenDocIds,
|
|
&$sequence
|
|
) {
|
|
$src = (string) ($match['url'] ?? '');
|
|
|
|
if (!preg_match('#/document(?P<path>/[^"\']+)#', $src, $m)) {
|
|
return $match[0];
|
|
}
|
|
|
|
$docRelPath = (string) $m['path'];
|
|
$docId = \DocumentManager::get_document_id($courseInfo, $docRelPath);
|
|
if (empty($docId)) {
|
|
return $match[0];
|
|
}
|
|
|
|
$docId = (int) $docId;
|
|
|
|
if (!isset($seenDocIds[$docId])) {
|
|
$doc = \DocumentManager::get_document_data_by_id($docId, $courseInfo['code']);
|
|
|
|
if (!empty($doc) && !empty($doc['path'])) {
|
|
$docPath = (string) $doc['path'];
|
|
$rel = ltrim(str_replace('\\', '/', $docPath), '/');
|
|
$dir = dirname($rel);
|
|
$dir = ($dir === '.' ? '' : $dir.'/');
|
|
$filepath = '/'.$dir;
|
|
$filepath = $this->ensureTrailingSlash($filepath);
|
|
|
|
$filename = basename($rel);
|
|
$absolutePath = $this->course->path.'document'.$docPath;
|
|
|
|
$sequence++;
|
|
$fileId = $this->buildQuestionEmbeddedFileId($itemId, $sequence);
|
|
|
|
$files[] = [
|
|
'id' => $fileId,
|
|
'contenthash' => is_file($absolutePath) ? sha1_file($absolutePath) : hash('sha1', $filename),
|
|
'contextid' => $contextId,
|
|
'component' => 'question',
|
|
'filearea' => $fileArea,
|
|
'itemid' => $itemId,
|
|
'filepath' => $filepath,
|
|
'documentpath' => 'document'.$docPath,
|
|
'filename' => $filename,
|
|
'userid' => $adminId,
|
|
'filesize' => (int) ($doc['size'] ?? 0),
|
|
'mimetype' => $fileExport->getMimeType($docPath),
|
|
'status' => 0,
|
|
'timecreated' => time() - 3600,
|
|
'timemodified' => time(),
|
|
'source' => (string) ($doc['title'] ?? $filename),
|
|
'author' => 'Unknown',
|
|
'license' => 'allrightsreserved',
|
|
];
|
|
}
|
|
|
|
$seenDocIds[$docId] = true;
|
|
}
|
|
|
|
$relHtml = ltrim($docRelPath, '/');
|
|
$pluginPath = '@@PLUGINFILE@@/'.$relHtml;
|
|
|
|
return str_replace($src, $pluginPath, $match[0]);
|
|
},
|
|
$html
|
|
);
|
|
|
|
return [
|
|
'content' => (string) $normalizedHtml,
|
|
'files' => $files,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Build a deterministic answer id for one question answer.
|
|
*/
|
|
private function buildStableQuestionAnswerId(int $questionId, int $answerIndex): int
|
|
{
|
|
return ($questionId * 1000) + $answerIndex;
|
|
}
|
|
|
|
/**
|
|
* Build a stable question-bank course context id for backup purposes.
|
|
*/
|
|
private function buildQuestionBankContextId(int $courseId): int
|
|
{
|
|
$contextId = MoodleExport::getBackupCourseContextId();
|
|
|
|
if ($contextId > 0) {
|
|
return $contextId;
|
|
}
|
|
|
|
return 700000000 + max(1, $courseId);
|
|
}
|
|
|
|
/**
|
|
* Build a clean question name from the question text.
|
|
*/
|
|
private function sanitizeQuestionName(string $raw, int $maxLen = 255): string
|
|
{
|
|
$text = trim($raw);
|
|
if ($text === '') {
|
|
return 'Question';
|
|
}
|
|
|
|
$text = html_entity_decode($text, ENT_QUOTES | ENT_HTML5, 'UTF-8');
|
|
$text = strip_tags($text);
|
|
$text = preg_replace('/\s+/u', ' ', $text);
|
|
$text = trim($text);
|
|
|
|
if ($text === '') {
|
|
return 'Question';
|
|
}
|
|
|
|
if (function_exists('mb_strlen') && function_exists('mb_substr')) {
|
|
if (mb_strlen($text, 'UTF-8') > $maxLen) {
|
|
$text = mb_substr($text, 0, $maxLen, 'UTF-8');
|
|
}
|
|
} elseif (strlen($text) > $maxLen) {
|
|
$text = substr($text, 0, $maxLen);
|
|
}
|
|
|
|
return $text;
|
|
}
|
|
}
|