%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/* For licensing terms, see /license.txt */
/**
* Class MoodleImport.
*
* @author José Loguercio <jose.loguercio@beeznest.com>,
* @author Julio Montoya <gugli100@gmail.com>
*/
class MoodleImport
{
/**
* Import moodle file.
*
* @param resource $uploadedFile *.* mbz file moodle course backup
*
* @throws Exception
*
* @return bool
*/
public function import($uploadedFile)
{
$debug = false;
if (UPLOAD_ERR_OK !== $uploadedFile['error']) {
throw new Exception(get_lang('UploadError'));
}
$cachePath = api_get_path(SYS_ARCHIVE_PATH);
$tempPath = $uploadedFile['tmp_name'];
$nameParts = explode('.', $uploadedFile['name']);
$extension = array_pop($nameParts);
$name = basename($tempPath).".$extension";
if (!move_uploaded_file($tempPath, api_get_path(SYS_ARCHIVE_PATH).$name)) {
throw new Exception(get_lang('UploadError'));
}
$filePath = $cachePath.$name;
if (!is_readable($filePath)) {
throw new Exception(get_lang('UploadError'));
}
$mimeType = mime_content_type($filePath);
$folder = api_get_unique_id();
$destinationDir = api_get_path(SYS_ARCHIVE_PATH).$folder;
mkdir($destinationDir, api_get_permissions_for_new_directories(), true);
switch ($mimeType) {
case 'application/gzip':
case 'application/x-gzip':
$backUpFile = new PharData($filePath);
if (false === $backUpFile->extractTo($destinationDir)) {
throw new Exception(get_lang('ErrorImportingFile'));
}
if (!file_exists($destinationDir.'/moodle_backup.xml')) {
throw new Exception(get_lang('FailedToImportThisIsNotAMoodleFile'));
}
break;
case 'application/zip':
$package = new PclZip($filePath);
$mainFileKey = 0;
$packageContent = $package->listContent();
if (!empty($packageContent)) {
foreach ($packageContent as $index => $value) {
if ($value['filename'] === 'moodle_backup.xml') {
$mainFileKey = $index;
break;
}
}
}
if (!$mainFileKey) {
throw new Exception(get_lang('FailedToImportThisIsNotAMoodleFile'));
}
$package->extract(PCLZIP_OPT_PATH, $destinationDir);
break;
}
$courseInfo = api_get_course_info();
// This process will upload all question resource files
$filesXml = @file_get_contents($destinationDir.'/files.xml');
$mainFileModuleValues = $this->getAllQuestionFiles($filesXml);
$currentResourceFilePath = $destinationDir.'/files/';
$importedFiles = [];
if ($debug) {
error_log('loading files');
}
$_POST['moodle_import'] = true;
$_POST['language'] = $courseInfo['language'];
$modScormFileZips = [];
$allFiles = [];
foreach ($mainFileModuleValues as $fileInfo) {
$dirs = new RecursiveDirectoryIterator($currentResourceFilePath);
foreach (new RecursiveIteratorIterator($dirs) as $file) {
if (!is_file($file) || false === strpos($file, $fileInfo['contenthash'])) {
continue;
}
if (isset($importedFiles[$fileInfo['filename']])) {
continue;
}
if ($debug) {
error_log($fileInfo['filename']);
}
$files = [];
$files['file']['name'] = $fileInfo['filename'];
$files['file']['tmp_name'] = $file->getPathname();
$files['file']['type'] = $fileInfo['mimetype'];
$files['file']['error'] = 0;
$files['file']['size'] = $fileInfo['filesize'];
$files['file']['from_file'] = true;
$files['file']['move_file'] = true;
if (isset($fileInfo['modscorm']) && true === $fileInfo['modscorm']) {
if ('application/zip' == $fileInfo['mimetype']) {
$modScormFileZips[$fileInfo['contenthash']] = $files;
}
continue;
}
$allFiles[$fileInfo['contextid']][] = $files;
}
}
$xml = @file_get_contents($destinationDir.'/moodle_backup.xml');
$doc = new DOMDocument();
$res = @$doc->loadXML($xml);
if (empty($res)) {
removeDir($destinationDir);
unlink($filePath);
throw new Exception(get_lang('FailedToImportThisIsNotAMoodleFile'));
}
// It process the sections as learnpaths
$sections = $this->readSections($xml, $destinationDir);
$activities = $doc->getElementsByTagName('activity');
$sectionLpValues = $this->processSections($sections, $activities);
require_once api_get_path(SYS_CODE_PATH).'forum/forumfunction.inc.php';
if ($debug) {
error_log('Loading activities: '.count($activities));
}
$previousItemId = 0;
$lpItemId = null;
foreach ($activities as $activity) {
if (empty($activity->childNodes->length)) {
continue;
}
$currentItem = [];
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
$moduleName = isset($currentItem['modulename']) ? $currentItem['modulename'] : false;
if ($debug) {
error_log('moduleName: '.$moduleName);
}
switch ($moduleName) {
case 'lesson':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readLessonModule($moduleXml);
$this->processLesson($moduleValues, $allFiles);
break;
case 'assign':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readAssignModule($moduleXml);
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$assignId = $this->processAssignment($moduleValues, $allFiles, $sectionPath);
// It is added as item in Learnpath
if (!empty($currentItem['sectionid']) && !empty($assignId)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'student_publication', $assignId, $moduleValues['name'], $previousItemId);
}
break;
case 'scorm':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readScormModule($moduleXml);
$this->processScorm($moduleValues, $modScormFileZips);
break;
case 'glossary':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readGlossaryModule($moduleXml, $currentItem['moduleid']);
$this->processGlossary($moduleValues, $currentItem['moduleid'], $allFiles, '');
break;
case 'label':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readHtmlModule($moduleXml, $moduleName);
$sectionPath = isset($currentItem['sectionid']) ? '/'.$sectionLpValues[$currentItem['sectionid']]['sectionPath'].'/' : '/';
$contextId = $moduleValues['attributes']['contextid'];
if (isset($currentItem['sectionid'])) {
$sectionLp = $sectionLpValues[$currentItem['sectionid']];
$lpId = $sectionLp['lpId'];
$chapterTitle = $moduleValues['name'] ?? 'Capítulo sin título';
if (!empty($lpId)) {
$lp = new \learnpath(
api_get_course_id(),
$lpId,
api_get_user_id()
);
$lpItemId = $lp->add_item(
0,
$previousItemId,
'dir',
0,
$chapterTitle,
'',
0,
0,
0,
0
);
}
} else {
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
$documentId = $this->processHtmlDocument($moduleValues, $moduleName, $importedFiles, $sectionPath);
if (!empty($currentItem['sectionid']) && !empty($documentId)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'document', $documentId, $moduleValues['name'], $previousItemId);
}
}
break;
case 'page':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readHtmlModule($moduleXml, $moduleName);
$sectionPath = isset($currentItem['sectionid']) ? '/'.$sectionLpValues[$currentItem['sectionid']]['sectionPath'].'/' : '/';
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
$documentId = $this->processHtmlDocument($moduleValues, $moduleName, $importedFiles, $sectionPath);
// It is added as item in Learnpath
if (!empty($currentItem['sectionid']) && !empty($documentId)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'document', $documentId, $moduleValues['name'], $previousItemId);
}
break;
case 'forum':
$catForumValues = [];
// Read the current forum module xml.
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readForumModule($moduleXml);
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
// Create a Forum category based on Moodle forum type.
$catForumValues['forum_category_title'] = $moduleValues['type'];
$catForumValues['forum_category_comment'] = '';
$catId = store_forumcategory(
$catForumValues,
$courseInfo,
false
);
$forumValues = [];
$forumValues['forum_title'] = $moduleValues['name'];
$forumValues['forum_image'] = '';
$moduleValues['intro'] = $this->replaceMoodleChamiloCoursePath($moduleValues['intro'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $moduleValues['intro']);
}
$forumValues['forum_comment'] = $moduleValues['intro'];
$forumValues['forum_category'] = $catId;
$forumValues['moderated'] = 0;
$forumId = store_forum($forumValues, $courseInfo, true);
if (!empty($moduleValues['discussions'])) {
$forum = get_forums($forumId);
foreach ($moduleValues['discussions'] as $discussion) {
$moduleValues['intro'] = $this->replaceMoodleChamiloCoursePath($moduleValues['intro'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $moduleValues['intro']);
}
$postText = '';
if (!empty($discussion['posts'])) {
$postText = $discussion['posts'][0]['message'];
$postText = $this->replaceMoodleChamiloCoursePath($postText, $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $postText);
}
}
store_thread(
$forum,
[
'forum_id' => $forumId,
'thread_id' => 0,
'gradebook' => 0,
'post_title' => $discussion['name'],
'post_text' => $postText,
'category_id' => 1,
'numeric_calification' => 0,
'calification_notebook_title' => 0,
'weight_calification' => 0.00,
'thread_peer_qualify' => 0,
'lp_item_id' => 0,
],
[],
false
);
}
}
// It is added as item in Learnpath
if (!empty($currentItem['sectionid']) && !empty($forumId)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'forum', $forumId, $moduleValues['name'], $previousItemId);
}
break;
case 'quiz':
// Read the current quiz module xml.
// The quiz case is the very complicate process of all the import.
// Please if you want to review the script, try to see the readingXML functions.
// The readingXML functions in this clases do all the mayor work here.
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$questionsXml = @file_get_contents($destinationDir.'/questions.xml');
// Detect version of Moodle.
$version = $this->detectMoodleVersion($destinationDir);
if ($version === 4) {
// If version is 4, use the V4 method to read quiz and questions.
$moduleValues = $this->readQuizModuleV4($moduleXml);
$questionValuesList = $this->readMainQuestionsXmlV4($questionsXml, $moduleXml);
} else {
// Otherwise use the standard method for older versions.
$moduleValues = $this->readQuizModule($moduleXml);
$questionValuesList = [];
foreach ($moduleValues['question_instances'] as $index => $question) {
$questionValuesList[] = $this->readMainQuestionsXml($questionsXml, $question['questionid']);
}
}
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
// At this point we got all the prepared resources from Moodle file
// $moduleValues variable contains all the necesary info to the quiz import
// var_dump($moduleValues); // <-- uncomment this to see the final array
// Create exercise (quiz)
$exercise = new Exercise($courseInfo['real_id']);
if ($debug) {
error_log('quiz:'.$moduleValues['name']);
}
$title = Exercise::format_title_variable($moduleValues['name']);
$exercise->updateTitle($title);
$introText = $this->replaceMoodleChamiloCoursePath($moduleValues['intro'], $sectionPath);
$exercise->updateDescription($introText);
$exercise->updateAttempts($moduleValues['attempts_number']);
// Set feedback type depending on behavior
$feedbackType = 2;
if (in_array($moduleValues['preferredbehaviour'], ['adaptive', 'adaptivenopenalty'])) {
$feedbackType = 1;
} elseif (in_array($moduleValues['preferredbehaviour'], ['immediatefeedback', 'immediatecbm'])) {
$feedbackType = 3;
} elseif ('deferredfeedback' === $moduleValues['preferredbehaviour']) {
$feedbackType = 0;
}
$exercise->updateFeedbackType($feedbackType);
// Shuffle questions and answers
$exercise->setRandom((int) $moduleValues['shufflequestions'] === 1 ? -1 : 0);
$exercise->updateRandomAnswers(!empty($moduleValues['shuffleanswers']));
// Set time limit and grading
$limeLimit = !empty($moduleValues['timelimit']) ? round($moduleValues['timelimit'] / 60) : 0;
$exercise->updateExpiredTime((int) $limeLimit);
$gradesXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/grades.xml');
$gradeQuizValues = $this->readQuizGradeModule($gradesXml, $moduleValues['quiz_id']);
$exercise->pass_percentage = !empty($gradeQuizValues['grademax']) ? round(($gradeQuizValues['gradepass'] * 100) / $gradeQuizValues['grademax']) : 0;
// Set type (single question per page or all in one)
$exercise->updateType((int) $moduleValues['questionsperpage'] === 1 ? 2 : 1);
// Set start and end times
$exercise->start_time = !empty($moduleValues['timeopen']) ? api_get_utc_datetime($moduleValues['timeopen']) : null;
$exercise->end_time = !empty($moduleValues['timeclose']) ? api_get_utc_datetime($moduleValues['timeclose']) : null;
// Save the quiz
$exercise->save();
// Process and import questions (shared code for both versions)
foreach ($questionValuesList as $index => $questionValues) {
// Set Question Type from Moodle XML element <qtype>
$qType = $questionValues['qtype'];
$questionType = $this->matchMoodleChamiloQuestionTypes($questionValues);
$questionInstance = Question::getInstance($questionType);
if (empty($questionInstance)) {
continue;
}
if ($debug) {
error_log('question: '.$questionValues['questionid']);
}
$questionInstance->updateTitle($questionValues['name']);
$questionText = $this->replaceMoodleChamiloCoursePath($questionValues['questiontext'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $questionText);
}
$questionInstance->updateDescription($questionText);
$questionInstance->updateLevel(1);
$questionInstance->updateCategory(0);
//Save normal question if NOT media
if ($questionInstance->type != MEDIA_QUESTION) {
$questionInstance->save($exercise);
// modify the exercise
$exercise->addToList($questionInstance->iid);
$exercise->update_question_positions();
}
// Now process the answers for the question
$questionList = $questionValues['plugin_qtype_'.$qType.'_question'];
$this->processAnswers($exercise, $questionList, $qType, $questionInstance, $questionValues, $importedFiles, $sectionPath);
}
// Add to learnpath if applicable
if (!empty($currentItem['sectionid']) && !empty($exercise->iid)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'quiz', $exercise->iid, $title, $previousItemId);
}
break;
case 'folder':
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$filesXml = @file_get_contents($destinationDir.'/files.xml');
$moduleValues = $this->readFolderModule($moduleXml);
$mainFileModuleValues = $this->readFolderModuleFilesXml(
$filesXml,
$moduleValues['contextid']
);
$resourcesFiles = [];
$currentResourceFilePath = $destinationDir.'/files/';
$dirs = new RecursiveDirectoryIterator($currentResourceFilePath);
foreach (new RecursiveIteratorIterator($dirs) as $file) {
foreach ($mainFileModuleValues['files'] as $info) {
if (!is_file($file) || false === strpos($file, $info['contenthash'])) {
continue;
}
$files = [];
$files['file']['name'] = $info['filename'];
$files['file']['tmp_name'] = $file->getPathname();
$files['file']['type'] = $info['mimetype'];
$files['file']['error'] = 0;
$files['file']['size'] = $info['filesize'];
$files['file']['from_file'] = true;
$files['file']['move_file'] = true;
$files['file']['filepath'] = $info['filepath'];
$resourcesFiles[] = $files;
}
}
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$lpId = (int) $sectionLpValues[$currentItem['sectionid']]['lpId'];
$this->processSectionFolderModule($mainFileModuleValues, $sectionPath, $moduleValues['name'], $resourcesFiles, $lpId, $previousItemId);
break;
case 'resource':
// Read the current resource module xml.
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$filesXml = @file_get_contents($destinationDir.'/files.xml');
$moduleValues = $this->readResourceModule($moduleXml);
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$mainFileModuleValues = $this->readMainFilesXml(
$filesXml,
$moduleValues['contextid']
);
$resourcesFiles = [];
$fileInfo = array_merge($moduleValues, $mainFileModuleValues, $currentItem);
$currentResourceFilePath = $destinationDir.'/files/';
$dirs = new RecursiveDirectoryIterator($currentResourceFilePath);
foreach (new RecursiveIteratorIterator($dirs) as $file) {
if (!is_file($file) || false === strpos($file, $fileInfo['contenthash'])) {
continue;
}
$files = [];
$files['file']['name'] = $fileInfo['filename'];
$files['file']['tmp_name'] = $file->getPathname();
$files['file']['type'] = $fileInfo['mimetype'];
$files['file']['error'] = 0;
$files['file']['size'] = $fileInfo['filesize'];
$files['file']['from_file'] = true;
$files['file']['move_file'] = true;
$_POST['language'] = $courseInfo['language'];
$_POST['moodle_import'] = true;
$resourcesFiles[] = $files;
}
if (!empty($resourcesFiles)) {
$lpId = 0;
if (!empty($currentItem['sectionid'])) {
$lpId = $sectionLpValues[$currentItem['sectionid']]['lpId'];
}
$importedFiles = $this->processSectionMultimedia($resourcesFiles, $sectionPath, $lpId, $previousItemId);
}
break;
case 'url':
// Read the current url module xml.
$moduleDir = $currentItem['directory'];
$moduleXml = @file_get_contents($destinationDir.'/'.$moduleDir.'/'.$moduleName.'.xml');
$moduleValues = $this->readUrlModule($moduleXml);
$sectionPath = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionPath'] : '';
$sectionName = isset($sectionLpValues[$currentItem['sectionid']]) ? $sectionLpValues[$currentItem['sectionid']]['sectionName'] : '';
$categoryId = 0;
if (!empty($sectionName)) {
$category = Link::getCategoryByName($sectionName);
if (!empty($category)) {
$categoryId = $category['iid'];
} else {
$_POST['category_title'] = $sectionName;
$_POST['description'] = '';
$categoryId = Link::addlinkcategory('category');
}
}
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
$_POST['title'] = $moduleValues['name'];
$_POST['url'] = $moduleValues['externalurl'];
$moduleValues['intro'] = $this->replaceMoodleChamiloCoursePath($moduleValues['intro'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $moduleValues['intro']);
}
$_POST['description'] = strip_tags($moduleValues['intro']);
$_POST['category_id'] = $categoryId;
$_POST['target'] = '_blank';
$linkId = Link::addlinkcategory('link');
// It is added as item in Learnpath
if (!empty($currentItem['sectionid']) && !empty($linkId)) {
$lpItemId = $this->processSectionItem($sectionLpValues[$currentItem['sectionid']]['lpId'], 'link', $linkId, $moduleValues['name'], $previousItemId);
}
break;
}
if (!empty($previousItemId)) {
$this->updateLpItemNextId($previousItemId, $lpItemId);
$this->updateLpItemPreviousId($lpItemId, $previousItemId);
}
$previousItemId = $lpItemId;
}
if (!empty($sectionLpValues)) {
foreach ($sectionLpValues as $section) {
if (!empty($section['sectionPath'])) {
$documentPath = '/'.$section['sectionPath'];
$baseWorkDir = api_get_path(SYS_COURSE_PATH).$courseInfo['path'].'/document';
$checkDir = $baseWorkDir.$documentPath;
if ($this->isEmptyDir($checkDir)) {
$document = DocumentManager::getDocumentByPathInCourse($courseInfo, $documentPath);
my_delete($checkDir);
// Hard delete.
DocumentManager::deleteDocumentFromDb(
$document[0]['iid'],
$courseInfo,
api_get_session_id(),
true
);
}
}
}
}
if ($debug) {
error_log('Finish');
}
removeDir($destinationDir);
unlink($filePath);
return true;
}
/**
* Detects the Moodle version from the backup XML file.
*
* @param string $destinationDir The directory where the moodle_backup.xml is located.
*
* @return int Returns 4 if the Moodle version is 4 or higher, otherwise returns 3.
*/
public function detectMoodleVersion($destinationDir): int
{
$moodleBackupXmlPath = $destinationDir.'/moodle_backup.xml';
$xml = file_get_contents($moodleBackupXmlPath);
$doc = new DOMDocument();
$doc->loadXML($xml);
$backupRelease = $doc->getElementsByTagName('backup_release');
$version = null;
foreach ($backupRelease as $release) {
$version = (float) $release->nodeValue;
}
return $version >= 4 ? 4 : 3;
}
/**
* Replace the path from @@PLUGINFILE@@ to a correct chamilo path.
*
* @param $text
* @param string $sectionPath
*
* @return string
*/
public function replaceMoodleChamiloCoursePath($text, $sectionPath = '')
{
if (!empty($sectionPath)) {
$sectionPath = '/'.$sectionPath;
}
$multimediaPath = $sectionPath.'/Multimedia';
$coursePath = api_get_course_path();
$text = str_replace(
'@@PLUGINFILE@@',
'/courses/'.$coursePath.'/document'.$multimediaPath,
$text
);
return $text;
}
/**
* Adds an item to a learning path section and processes its relationships.
*
* @param int $lpId The ID of the learning path.
* @param string $itemType The type of the item (e.g., quiz, document).
* @param int $itemId The ID of the item to be added.
* @param string $itemTitle The title of the item.
* @param int|null $previousItemId The ID of the previous item (optional).
*
* @return int The ID of the newly added learning path item.
*/
public function processSectionItem($lpId, $itemType, $itemId, $itemTitle, $previousItemId = null): int
{
$lp = new \learnpath(
api_get_course_id(),
$lpId,
api_get_user_id()
);
$lpItemId = $lp->add_item(
0,
$previousItemId,
$itemType,
$itemId,
$itemTitle,
'',
0,
0,
0,
0
);
return $lpItemId;
}
/**
* It adds the section module as learnpath.
*
* @param $sections
*
* @return array|false
*/
public function processSections($sections, $activities)
{
if (empty($sections)) {
return false;
}
$courseInfo = api_get_course_info();
$documentPath = api_get_path(SYS_COURSE_PATH).$courseInfo['path'].'/document';
$i = 1;
$lpAdded = [];
foreach ($sections as $sectionId => $section) {
$countSectionActivities = $this->countSectionActivities($activities, $sectionId);
if ($countSectionActivities > 0) {
$lpName = $section['name'];
if ('$@NULL@$' == $lpName) {
$lpName = get_lang('Topic').' '.$i;
}
$lpDescription = $section['summary'];
$lpId = learnpath::add_lp(
api_get_course_id(),
$lpName,
$lpDescription,
'chamilo',
'manual'
);
$dirName = api_replace_dangerous_char($lpName);
create_unexisting_directory(
$courseInfo,
api_get_user_id(),
api_get_session_id(),
api_get_group_id(),
null,
$documentPath,
'/'.$dirName,
$lpName,
0
);
$lpAdded[$sectionId] = [
'lpId' => $lpId,
'sectionPath' => $dirName,
'sectionName' => $lpName,
];
$i++;
}
}
return $lpAdded;
}
/**
* It counts the activities inside a section module.
*
* @param $activities
* @param $sectionId
*
* @return int|void
*/
public function countSectionActivities($activities, $sectionId)
{
$sectionActivities = [];
$modulesLpTypes = ['url', 'resource', 'quiz', 'forum', 'page', 'label', 'assign'];
$i = 0;
foreach ($activities as $activity) {
if (empty($activity->childNodes->length)) {
continue;
}
$currentItem = [];
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
if (!empty($currentItem['sectionid']) && in_array($currentItem['modulename'], $modulesLpTypes)) {
$sectionActivities[$currentItem['sectionid']][$i] = $currentItem;
$i++;
}
}
$countActivities = 0;
if (isset($sectionActivities[$sectionId])) {
$countActivities = count($sectionActivities[$sectionId]);
}
return $countActivities;
}
/**
* It gets the sections from xml module.
*
* @param $xml
* @param $destinationDir
*
* @return array|false
*/
public function readSections($xml, $destinationDir)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($xml);
if (empty($res)) {
return false;
}
$sections = [];
$sectionNodes = $doc->getElementsByTagName('section');
foreach ($sectionNodes as $section) {
if (empty($section->childNodes->length)) {
continue;
}
$currentItem = [];
foreach ($section->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
if (!empty($currentItem['directory'])) {
$sectionDir = $destinationDir.'/'.$currentItem['directory'];
$sectionInfoXml = @file_get_contents($sectionDir.'/section.xml');
$sections[$currentItem['sectionid']] = $this->readSectionModule($sectionInfoXml);
}
}
return $sections;
}
/**
* It reads module xml to get section info.
*
* @param $sectionInfoXml
*
* @return array|false
*/
public function readSectionModule($sectionInfoXml)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($sectionInfoXml);
if (empty($res)) {
return false;
}
$sectionInfo = [];
$sectionNode = $doc->getElementsByTagName('section');
foreach ($sectionNode as $section) {
if (empty($section->childNodes->length)) {
continue;
}
foreach ($section->childNodes as $item) {
$sectionInfo[$item->nodeName] = $item->nodeValue;
}
}
return $sectionInfo;
}
/**
* It gets lesson information from module xml.
*
* @param $moduleXml
*
* @return array|false
*/
public function readLessonModule($moduleXml)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($moduleXml);
if (empty($res)) {
return false;
}
$activities = $doc->getElementsByTagName('lesson');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
$pages = $doc->getElementsByTagName('page');
$pagesList = [];
$counter = 0;
foreach ($pages as $page) {
if ($page->childNodes->length) {
foreach ($page->childNodes as $item) {
$pagesList[$counter][$item->nodeName] = $item->nodeValue;
}
$i = 0;
$answerNodes = $page->getElementsByTagName("answer");
$answers = [];
foreach ($answerNodes as $answer) {
foreach ($answer->childNodes as $n) {
$answers[$i][$n->nodeName] = $n->nodeValue;
}
$i++;
}
$pagesList[$counter]['answers'] = $answers;
$counter++;
}
}
$currentItem['pages'] = $pagesList;
$attributes = $this->getDocActivityAttributes($doc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* It gets assignment information from module xml.
*
* @param $moduleXml
*
* @return array|false
*/
public function readAssignModule($moduleXml)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($moduleXml);
if (empty($res)) {
return false;
}
$info = [];
$entries = $doc->getElementsByTagName('assign');
foreach ($entries as $entry) {
if (empty($entry->childNodes->length)) {
continue;
}
foreach ($entry->childNodes as $item) {
if (in_array($item->nodeName, ['name', 'intro', 'duedate', 'cutoffdate', 'grade'])) {
$info[$item->nodeName] = $item->nodeValue;
}
}
}
$configOpts = $doc->getElementsByTagName('plugin_config');
$config = [];
$counter = 0;
foreach ($configOpts as $opt) {
if (empty($opt->childNodes->length)) {
continue;
}
$pluginName = '';
foreach ($opt->childNodes as $item) {
if ('#text' == $item->nodeName) {
continue;
}
if ('plugin' == $item->nodeName && !in_array($item->nodeValue, ['onlinetext', 'file'])) {
break;
}
if ('subtype' == $item->nodeName && 'assignsubmission' != $item->nodeValue) {
break;
}
if ('name' == $item->nodeName && 'enabled' != $item->nodeValue) {
break;
}
if ('plugin' == $item->nodeName) {
$pluginName = $item->nodeValue;
}
if ('value' == $item->nodeName) {
$config[$pluginName]['enabled'] = (int) $item->nodeValue;
}
}
$counter++;
}
$info['config'] = $config;
$attributes = $this->getDocActivityAttributes($doc);
$info['attributes'] = $attributes;
return $info;
}
/**
* It gets the attributes of each activity from module xml.
*
* @param $doc
*
* @return array
*/
public function getDocActivityAttributes($doc)
{
$activityAttr = [];
$searchActivity = $doc->getElementsByTagName('activity');
foreach ($searchActivity as $searchNode) {
$activityAttr['contextid'] = $searchNode->getAttribute('contextid');
$activityAttr['modulename'] = $searchNode->getAttribute('modulename');
$activityAttr['moduleid'] = $searchNode->getAttribute('moduleid');
}
return $activityAttr;
}
/**
* It gest scorm information from module xml.
*
* @param $moduleXml
*
* @return array|false
*/
public function readScormModule($moduleXml)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($moduleXml);
if (empty($res)) {
return false;
}
$info = [];
$entries = $doc->getElementsByTagName('scorm');
$i = 0;
foreach ($entries as $entry) {
if (empty($entry->childNodes->length)) {
continue;
}
foreach ($entry->childNodes as $item) {
if (in_array($item->nodeName, ['name', 'reference', 'sha1hash', 'scormtype'])) {
$info[$i][$item->nodeName] = $item->nodeValue;
}
}
$i++;
}
return $info;
}
/**
* Get glossary information from module xml.
*
* @param $moduleXml
* @param $moduleId
*
* @return array|false
*/
public function readGlossaryModule($moduleXml, $moduleId)
{
$doc = new DOMDocument();
$res = @$doc->loadXML($moduleXml);
if (empty($res)) {
return false;
}
$glossaryInfo = [];
$entries = $doc->getElementsByTagName('entry');
$i = 0;
foreach ($entries as $entry) {
if (empty($entry->childNodes->length)) {
continue;
}
foreach ($entry->childNodes as $item) {
$glossaryInfo[$moduleId][$i][$item->nodeName] = $item->nodeValue;
}
$i++;
}
$attributes = $this->getDocActivityAttributes($doc);
$glossaryInfo['attributes'] = $attributes;
return $glossaryInfo;
}
/**
* It reads item html from module to documents.
*
* @param $moduleXml
* @param $moduleName
*
* @return array|false
*/
public function readHtmlModule($moduleXml, $moduleName)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName($moduleName);
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* It addes the files from a resources type folder.
*
* @param $files
* @param $mainFolderName
* @param $sectionPath
* @param int $lpId
* @param int $n
*/
public function processSectionFolderModule($mainFileModuleValues, $sectionPath, $mainFolderName, $resourcesFiles, $lpId = 0, $dspOrder = 0)
{
if (!empty($mainFileModuleValues['folder'])) {
$courseInfo = api_get_course_info();
$chapters = [];
$documentPath = api_get_path(SYS_COURSE_PATH).$courseInfo['path'].'/document';
// It creates the first lp chapter (module folder name)
$safeMainFolderName = api_replace_dangerous_char($mainFolderName);
$documentData = create_unexisting_directory(
$courseInfo,
api_get_user_id(),
api_get_session_id(),
api_get_group_id(),
null,
$documentPath,
'/'.$sectionPath.'/'.$safeMainFolderName,
$mainFolderName,
0
);
if (!empty($lpId) && !empty($documentData['iid'])) {
$lp = new \learnpath(
api_get_course_id(),
$lpId,
api_get_user_id()
);
$lpItemId = $lp->add_item(
0,
0,
'dir',
$documentData['iid'],
$mainFolderName,
'',
0,
0,
0,
$dspOrder
);
$chapters['/'] = $lpItemId;
}
// It checks the subfolder for second level.
foreach ($mainFileModuleValues['folder'] as $folder) {
if ('/' == $folder['filepath']) {
continue;
}
$folder['filepath'] = trim($folder['filepath'], '/');
$arrFolderPath = explode('/', $folder['filepath']);
if (1 == count($arrFolderPath)) {
$folderName = $arrFolderPath[0];
$safeFolderName = api_replace_dangerous_char($folderName);
$documentSubData = create_unexisting_directory(
$courseInfo,
api_get_user_id(),
api_get_session_id(),
api_get_group_id(),
null,
$documentPath,
'/'.$sectionPath.'/'.$safeMainFolderName.'/'.$safeFolderName,
$folderName,
0
);
if (!empty($lpId) && !empty($documentSubData['iid'])) {
$lp = new \learnpath(
api_get_course_id(),
$lpId,
api_get_user_id()
);
$lpItemId = $lp->add_item(
$chapters['/'],
0,
'dir',
$documentSubData['iid'],
$folderName,
'',
0,
0,
0
);
$chapters["/$folderName/"] = $lpItemId;
}
}
}
if (!empty($resourcesFiles)) {
foreach ($resourcesFiles as $file) {
$title = pathinfo($file['file']['name'], PATHINFO_FILENAME);
$path = $file['file']['filepath'];
if (1 == count(explode('/', trim($path, '/')))) {
$safePath = api_replace_dangerous_char($path);
$newSafePath = !empty($safePath) ? '/'.$sectionPath.'/'.$safeMainFolderName.'/'.$safePath : '/'.$sectionPath.'/'.$safeMainFolderName;
$data = DocumentManager::upload_document(
$file,
$newSafePath,
$title,
'',
null,
'overwrite',
true,
true,
'file',
false
);
if (!empty($lpId) && !empty($data['iid'])) {
// It is added as item in Learnpath
$lp = new \learnpath(
api_get_course_id(),
$lpId,
api_get_user_id()
);
$lpItemId = $lp->add_item(
$chapters[$path],
0,
'document',
$data['iid'],
$title,
'',
0,
0,
0
);
}
}
}
}
}
}
/**
* It reorganizes files imported to documents.
*
* @param $files
* @param $sectionPath
*
* @return array
*/
public function processSectionMultimedia($files, $sectionPath, $lpId = 0, $previousItemId = 0)
{
$importedFiles = [];
if (!empty($files)) {
$courseInfo = api_get_course_info();
if (!empty($sectionPath)) {
$sectionPath = '/'.trim($sectionPath, '/\\');
}
$documentPath = api_get_path(SYS_COURSE_PATH).$courseInfo['path'].'/document';
$multimediaPath = $documentPath.$sectionPath.'/Multimedia';
if (!is_dir($multimediaPath)) {
create_unexisting_directory(
$courseInfo,
api_get_user_id(),
api_get_session_id(),
api_get_group_id(),
null,
$documentPath,
$sectionPath.'/Multimedia',
'Multimedia',
0
);
}
foreach ($files as $file) {
$title = pathinfo($file['file']['name'], PATHINFO_FILENAME);
$path = !empty($lpId) ? $sectionPath : $sectionPath.'/Multimedia';
$data = DocumentManager::upload_document(
$file,
$path,
$title,
'',
null,
'overwrite',
true,
true,
'file',
false
);
if ($data) {
$importedFiles[$file['file']['name']] = basename($data['path']);
// It is added as item in Learnpath
if (!empty($lpId) && !empty($data['iid'])) {
$currentItemId = $this->processSectionItem($lpId, 'document', $data['iid'], $title, $previousItemId);
if (!empty($previousItemId)) {
$this->updateLpItemNextId($previousItemId, $currentItemId);
$this->updateLpItemPreviousId($currentItemId, $previousItemId);
}
$previousItemId = $currentItemId;
}
}
}
}
return $importedFiles;
}
/**
* It saves a learnpath from module xml.
*
* @param $moduleValues
*
* @return false
*/
public function processLesson($moduleValues, $allFiles = [])
{
if (!empty($moduleValues['pages'])) {
$qtypes = [
20 => 'page',
10 => 'essay',
5 => 'matching',
3 => 'multichoice',
1 => 'shortanswer',
2 => 'truefalse',
];
$items = $moduleValues['pages'];
$lpName = $moduleValues['name'];
$lpDescription = api_utf8_decode($moduleValues['intro']);
$lpId = learnpath::add_lp(
api_get_course_id(),
$lpName,
$lpDescription,
'chamilo',
'manual'
);
$dirName = api_replace_dangerous_char($lpName);
$courseInfo = api_get_course_info();
$documentPath = api_get_path(SYS_COURSE_PATH).$courseInfo['path'].'/document';
create_unexisting_directory(
$courseInfo,
api_get_user_id(),
api_get_session_id(),
api_get_group_id(),
null,
$documentPath,
'/'.$dirName,
$lpName,
0
);
$importedFiles = [];
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $dirName);
}
$questionList = [];
foreach ($items as $item) {
if (in_array($item['qtype'], array_keys($qtypes))) {
$qTypeName = $qtypes[$item['qtype']];
switch ($qTypeName) {
case 'page':
$pageValues = [];
$pageValues['name'] = $item['title'];
$pageValues['content'] = $item['contents'];
$sectionPath = '/'.$dirName.'/';
$documentId = $this->processHtmlDocument($pageValues, 'page', $importedFiles, $sectionPath);
$lpItemId = $this->processSectionItem($lpId, 'document', $documentId, $pageValues['name']);
break;
case 'essay':
case 'match':
case 'multichoice':
case 'shortanswer':
case 'truefalse':
$qType = $qtypes[$item['qtype']];
$question = [];
$question['qtype'] = $qType;
$question['name'] = $item['title'];
$question['questiontext'] = api_utf8_decode($item['contents']);
$question[$qType.'_values']['single'] = 1;
$question['questionType'] = $this->matchMoodleChamiloQuestionTypes($question);
$answers = [];
if (!empty($item['answers'])) {
$defaultmark = 0;
foreach ($item['answers'] as $answer) {
$answerValue = [];
$answerValue['answertext'] = api_utf8_decode($answer['answer_text']);
$answerValue['feedback'] = api_utf8_decode($answer['response']);
$answerValue['fraction'] = $answer['score'];
$defaultmark += $answer['score'];
$answers[] = $answerValue;
}
$question['defaultmark'] = $defaultmark;
}
$question['answers'] = $answers;
$questionList[] = $question;
break;
}
}
}
if (!empty($questionList)) {
$courseInfo = api_get_course_info();
// It creates a quiz for those questions.
$exercise = new Exercise($courseInfo['real_id']);
$quizLpName = $lpName.' - '.get_lang('Quiz');
$title = Exercise::format_title_variable($quizLpName);
$exercise->updateTitle($title);
$moduleValues['intro'] = $this->replaceMoodleChamiloCoursePath($moduleValues['intro'], $dirName);
$exercise->updateDescription(api_utf8_decode($moduleValues['intro']));
$exercise->updateAttempts(0);
$exercise->updateFeedbackType(0);
$exercise->setRandom(0);
$exercise->updateRandomAnswers(false);
$exercise->updateExpiredTime(0);
$exercise->updateType(2);
$exercise->updateResultsDisabled(0);
// Create the new Quiz
$exercise->save();
$lpItemId = $this->processSectionItem($lpId, 'quiz', $exercise->iid, $quizLpName);
// Ok, we got the Quiz and create it, now its time to add the Questions
foreach ($questionList as $question) {
$questionInstance = Question::getInstance($question['questionType']);
if (empty($questionInstance)) {
continue;
}
$questionInstance->updateTitle($question['name']);
$questionText = $question['questiontext'];
$questionText = $this->replaceMoodleChamiloCoursePath($questionText, $dirName);
$questionInstance->updateDescription($questionText);
$questionInstance->updateLevel(1);
$questionInstance->updateCategory(0);
//Save normal question if NOT media
if ($questionInstance->type != MEDIA_QUESTION) {
$questionInstance->save($exercise);
// modify the exercise
$exercise->addToList($questionInstance->iid);
$exercise->update_question_positions();
}
$this->processAnswers(
$exercise,
$question['answers'],
$question['qtype'],
$questionInstance,
$question,
$importedFiles,
$dirName
);
}
}
}
return false;
}
/**
* It saves a student publication from module xml.
*
* @param $assign
*
* @return bool|int
*/
public function processAssignment($assign, $allFiles = [], $sectionPath = '')
{
if (!empty($assign)) {
require_once api_get_path(SYS_CODE_PATH).'work/work.lib.php';
$importedFiles = [];
$contextId = $assign['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
$values = [];
$values['new_dir'] = $assign['name'];
if (!empty($assign['cutoffdate'])) {
$values['enableEndDate'] = 1;
$values['ends_on'] = date('Y-m-d H:i', $assign['cutoffdate']);
}
if (!empty($assign['duedate'])) {
$values['enableExpiryDate'] = 1;
$values['expires_on'] = date('Y-m-d H:i', $assign['duedate']);
}
$values['work_title'] = $assign['name'];
$assign['intro'] = $this->replaceMoodleChamiloCoursePath($assign['intro'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $assign['intro']);
}
$values['description'] = api_utf8_decode($assign['intro']);
$values['qualification'] = (int) $assign['grade'];
$values['weight'] = (int) $assign['grade'];
$values['allow_text_assignment'] = 2;
if (!empty($assign['config'])) {
if (1 == (int) $assign['config']['onlinetext']['enabled'] && 1 == (int) $assign['config']['file']['enabled']) {
$values['allow_text_assignment'] = 0;
} elseif (1 == (int) $assign['config']['onlinetext']['enabled'] && empty($assign['config']['file']['enabled'])) {
$values['allow_text_assignment'] = 1;
} elseif (empty($assign['config']['onlinetext']['enabled']) && 1 == (int) $assign['config']['file']['enabled']) {
$values['allow_text_assignment'] = 2;
}
}
$assignId = addDir(
$values,
api_get_user_id(),
api_get_course_info(),
api_get_group_id(),
api_get_session_id()
);
return $assignId;
}
return false;
}
/**
* It saves a scorm from module xml.
*
* @param $moduleValues
* @param $modScormFileZips
*
* @return bool
*/
public function processScorm($moduleValues, $modScormFileZips)
{
if (!empty($moduleValues)) {
foreach ($moduleValues as $info) {
$sha1hash = $info['sha1hash'];
if (!empty($modScormFileZips[$sha1hash])) {
$scormFile = $modScormFileZips[$sha1hash];
$oScorm = new scorm();
$manifest = $oScorm->import_package(
$scormFile['file']
);
if (!empty($manifest)) {
$oScorm->parse_manifest($manifest);
$oScorm->import_manifest(
api_get_course_id(),
1,
0,
0,
$info['name']
);
}
$oScorm->set_proximity($info['scormtype']);
$oScorm->set_maker('Scorm');
$oScorm->set_jslib('scorm_api.php');
}
}
return true;
}
return false;
}
/**
* It saves glossary terms from module xml.
*
* @param $moduleValues
* @param $moduleId
*
* @return bool
*/
public function processGlossary($moduleValues, $moduleId, $allFiles = [], $sectionPath = '/')
{
$importedFiles = [];
$contextId = $moduleValues['attributes']['contextid'];
if (isset($allFiles[$contextId])) {
$importedFiles = $this->processSectionMultimedia($allFiles[$contextId], $sectionPath);
}
if (!empty($moduleValues[$moduleId])) {
foreach ($moduleValues[$moduleId] as $entry) {
$values = [];
$values['name'] = $entry['concept'];
$entry['definition'] = $this->replaceMoodleChamiloCoursePath($entry['definition'], $sectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $entry['definition']);
}
$values['description'] = $entry['definition'];
GlossaryManager::save_glossary($values);
}
return true;
}
return false;
}
/**
* It process the module as document html.
*
* @param $moduleValues
* @param $moduleName
*
* @return false|int
*/
public function processHtmlDocument($moduleValues, $moduleName, $importedFiles = [], $sectionPath = '/')
{
$dir = $sectionPath;
$filepath = api_get_path(SYS_COURSE_PATH).api_get_course_path().'/document'.$dir;
$title = trim($moduleValues['name']);
if ('$@NULL@$' == $title) {
$title = get_lang('Tag');
}
// Setting the filename
$filename = $title;
$filename = addslashes(trim($filename));
$filename = Security::remove_XSS($filename);
$filename = api_replace_dangerous_char($filename);
$filename = disable_dangerous_file($filename);
$filename .= DocumentManager::getDocumentSuffix(
api_get_course_info(),
api_get_session_id(),
api_get_group_id()
);
$extension = 'html';
$content = ('page' == $moduleName ? $moduleValues['content'] : $moduleValues['intro']);
$content = api_html_entity_decode($content);
$cleanSectionPath = trim($sectionPath, '/\\');
$content = $this->replaceMoodleChamiloCoursePath($content, $cleanSectionPath);
if ($importedFiles) {
$this->fixPathInText($importedFiles, $content);
}
if ($fp = @fopen($filepath.$filename.'.'.$extension, 'w')) {
$content = str_replace(
api_get_path(WEB_COURSE_PATH),
api_get_configuration_value('url_append').api_get_path(REL_COURSE_PATH),
$content
);
fputs($fp, $content);
fclose($fp);
chmod($filepath.$filename.'.'.$extension, api_get_permissions_for_new_files());
$fileSize = filesize($filepath.$filename.'.'.$extension);
$saveFilePath = $dir.$filename.'.'.$extension;
$documentId = add_document(
api_get_course_info(),
$saveFilePath,
'file',
$fileSize,
$title
);
if ($documentId) {
api_item_property_update(
api_get_course_info(),
TOOL_DOCUMENT,
$documentId,
'DocumentAdded',
api_get_user_id(),
[],
null,
null,
null,
api_get_session_id()
);
// Update parent folders
item_property_update_on_folder(api_get_course_info(), $dir, api_get_user_id());
}
return $documentId;
}
return false;
}
/**
* Read and validate the forum module XML.
*
* @param resource $moduleXml XML file
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readForumModule($moduleXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('forum');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
if (in_array($item->nodeName, ['type', 'name', 'intro', 'grade_forum'])) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
}
$discussions = $moduleDoc->getElementsByTagName('discussion');
$discussionsList = [];
$counter = 0;
foreach ($discussions as $discussion) {
if ($discussion->childNodes->length) {
foreach ($discussion->childNodes as $item) {
$discussionsList[$counter][$item->nodeName] = $item->nodeValue;
}
$i = 0;
$postsNodes = $discussion->getElementsByTagName("post");
$posts = [];
foreach ($postsNodes as $post) {
foreach ($post->childNodes as $n) {
$posts[$i][$n->nodeName] = $n->nodeValue;
}
$i++;
}
$discussionsList[$counter]['posts'] = $posts;
$counter++;
}
}
$currentItem['discussions'] = $discussionsList;
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* Read and validate the folder module XML.
*
* @param resource $moduleXml XML file
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readFolderModule($moduleXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('folder');
$mainActivity = $moduleDoc->getElementsByTagName('activity');
$contextId = $mainActivity->item(0)->getAttribute('contextid');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
$currentItem['contextid'] = $contextId;
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* Read and validate the resource module XML.
*
* @param resource $moduleXml XML file
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readResourceModule($moduleXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('resource');
$mainActivity = $moduleDoc->getElementsByTagName('activity');
$contextId = $mainActivity->item(0)->getAttribute('contextid');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
$currentItem['contextid'] = $contextId;
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* Read and validate the url module XML.
*
* @param resource $moduleXml XML file
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readUrlModule($moduleXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('url');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
}
}
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* It gets the grade values about a quiz imported.
*
* @param $gradeXml
* @param $quizId
*
* @return false|mixed
*/
public function readQuizGradeModule($gradeXml, $quizId)
{
$doc = new DOMDocument();
$gradeRes = @$doc->loadXML($gradeXml);
if (empty($gradeRes)) {
return false;
}
$entries = $doc->getElementsByTagName('grade_item');
$info = [];
$i = 0;
foreach ($entries as $entry) {
if (empty($entry->childNodes->length)) {
continue;
}
foreach ($entry->childNodes as $item) {
if (in_array($item->nodeName, ['iteminstance', 'grademax', 'grademin', 'gradepass'])) {
$info[$i][$item->nodeName] = $item->nodeValue;
}
}
$i++;
}
$grades = [];
if (!empty($info)) {
foreach ($info as $res) {
$grades[$res['iteminstance']] = $res;
}
return $grades[$quizId];
}
return false;
}
/**
* Read and validate the quiz module XML.
*
* @param resource $moduleXml XML file
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readQuizModule($moduleXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($moduleXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('quiz');
$currentItem = [];
foreach ($activities as $activity) {
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
}
$currentItem['quiz_id'] = $activity->getAttribute('id');
}
}
$questions = $moduleDoc->getElementsByTagName('question_instance');
$questionList = [];
$counter = 0;
foreach ($questions as $question) {
if ($question->childNodes->length) {
foreach ($question->childNodes as $item) {
$questionList[$counter][$item->nodeName] = $item->nodeValue;
}
$counter++;
}
}
$currentItem['question_instances'] = $questionList;
$attributes = $this->getDocActivityAttributes($moduleDoc);
$currentItem['attributes'] = $attributes;
return $currentItem;
}
/**
* Reads and parses the quiz module XML for Moodle version 4.
*
* @param string $moduleXml The XML content of the quiz module.
*
* @return array Returns an array with quiz data and question instances.
*/
public function readQuizModuleV4($moduleXml)
{
$moduleDoc = new DOMDocument();
@$moduleDoc->loadXML($moduleXml);
$quizData = [];
$quizNodes = $moduleDoc->getElementsByTagName('quiz');
foreach ($quizNodes as $quizNode) {
foreach ($quizNode->childNodes as $child) {
$quizData[$child->nodeName] = $child->nodeValue;
}
$quizData['quiz_id'] = $quizNode->getAttribute('id');
}
$quizData['question_instances'] = [];
$questionInstances = $moduleDoc->getElementsByTagName('question_instance');
foreach ($questionInstances as $questionInstance) {
$questionId = $questionInstance->getAttribute('id');
foreach ($questionInstance->childNodes as $child) {
$quizData['question_instances'][] = [
'questionid' => $questionId,
$child->nodeName => $child->nodeValue,
];
}
}
return $quizData;
}
/**
* Reads and processes quiz questions for Moodle version 4.
*
* @param string $questionsXml The XML content containing question data.
* @param string $quizXml The XML content containing quiz data.
*
* @return array Returns an array of processed questions, either by category or by question bank reference.
*/
public function readMainQuestionsXmlV4($questionsXml, $quizXml)
{
$questionsDoc = new DOMDocument();
@$questionsDoc->loadXML($questionsXml);
$quizDoc = new DOMDocument();
@$quizDoc->loadXML($quizXml);
$isByCategory = $quizDoc->getElementsByTagName('question_set_reference')->length > 0;
$isByBankReference = $quizDoc->getElementsByTagName('question_reference')->length > 0;
if ($isByCategory) {
return $this->processByCategory($questionsDoc, $quizDoc);
} elseif ($isByBankReference) {
return $this->processByBankReference($questionsDoc, $quizDoc);
}
return [];
}
/**
* Search the files of a resource type folder in main Files XML.
*
* @param resource $filesXml XML file
* @param int $contextId
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readFolderModuleFilesXml($filesXml, $contextId = null)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($filesXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('file');
$filesInfo = [];
$i = 0;
foreach ($activities as $activity) {
if (empty($activity->childNodes->length)) {
continue;
}
foreach ($activity->childNodes as $item) {
if (in_array($item->nodeName, ['filename', 'filesize', 'contenthash', 'contextid', 'filepath', 'filesize', 'mimetype'])) {
$filesInfo[$i][$item->nodeName] = $item->nodeValue;
}
}
$i++;
}
$currentItem = [];
if (!empty($filesInfo)) {
foreach ($filesInfo as $info) {
if (!empty($info['filesize'])) {
$currentItem[$info['contextid']]['files'][] = $info;
} else {
$currentItem[$info['contextid']]['folder'][] = $info;
}
}
}
$files = isset($contextId) ? $currentItem[$contextId] : $currentItem;
return $files;
}
/**
* Search the current file resource in main Files XML.
*
* @param resource $filesXml XML file
* @param int $contextId
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readMainFilesXml($filesXml, $contextId)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($filesXml);
if (empty($moduleRes)) {
return false;
}
$activities = $moduleDoc->getElementsByTagName('file');
$filesInfo = [];
$i = 0;
foreach ($activities as $activity) {
if (empty($activity->childNodes->length)) {
continue;
}
foreach ($activity->childNodes as $item) {
if (in_array($item->nodeName, ['filename', 'filesize', 'contenthash', 'contextid', 'filesize', 'mimetype'])) {
$filesInfo[$i][$item->nodeName] = $item->nodeValue;
}
}
$i++;
}
$currentItem = [];
if (!empty($filesInfo)) {
foreach ($filesInfo as $info) {
if (!empty($info['filesize'])) {
$currentItem[$info['contextid']] = $info;
}
}
}
return $currentItem[$contextId];
}
/**
* Search the current question resource in main Questions XML.
*
* @param resource $questionsXml XML file
* @param int $questionId
*
* @return mixed|array if is a valid xml file, false otherwise
*/
public function readMainQuestionsXml($questionsXml, $questionId)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($questionsXml);
if (empty($moduleRes)) {
return false;
}
$questions = $moduleDoc->getElementsByTagName('question');
$currentItem = [];
foreach ($questions as $question) {
if ((int) $question->getAttribute('id') !== (int) $questionId) {
continue;
}
if (empty($question->childNodes->length)) {
continue;
}
$currentItem['questionid'] = $questionId;
$questionType = '';
foreach ($question->childNodes as $item) {
$currentItem[$item->nodeName] = $item->nodeValue;
if ('qtype' === $item->nodeName) {
$questionType = $item->nodeValue;
}
if ($item->nodeName != 'plugin_qtype_'.$questionType.'_question') {
continue;
}
$answer = $item->getElementsByTagName($this->getQuestionTypeAnswersTag($questionType));
$currentItem['plugin_qtype_'.$questionType.'_question'] = [];
for ($i = 0; $i <= $answer->length - 1; $i++) {
$label = 'plugin_qtype_'.$questionType.'_question';
$currentItem[$label][$i]['answerid'] = $answer->item($i)->getAttribute('id');
foreach ($answer->item($i)->childNodes as $properties) {
$currentItem[$label][$i][$properties->nodeName] = $properties->nodeValue;
}
}
$typeValues = $item->getElementsByTagName($this->getQuestionTypeOptionsTag($questionType));
for ($i = 0; $i <= $typeValues->length - 1; $i++) {
foreach ($typeValues->item($i)->childNodes as $properties) {
$currentItem[$questionType.'_values'][$properties->nodeName] = $properties->nodeValue;
if ($properties->nodeName !== 'sequence') {
continue;
}
$sequence = $properties->nodeValue;
$sequenceIds = explode(',', $sequence);
foreach ($sequenceIds as $qId) {
$questionMatch = $this->readMainQuestionsXml($questionsXml, $qId);
$currentItem['plugin_qtype_'.$questionType.'_question'][] = $questionMatch;
}
}
}
}
}
$this->traverseArray($currentItem, ['#text', 'question_hints', 'tags']);
return $currentItem;
}
/**
* return the correct question type options tag.
*
* @param string $questionType name
*
* @return string question type tag
*/
public function getQuestionTypeOptionsTag($questionType)
{
switch ($questionType) {
case 'match':
case 'ddmatch':
return 'matchoptions';
default:
return $questionType;
}
}
/**
* return the correct question type answers tag.
*
* @param string $questionType name
*
* @return string question type tag
*/
public function getQuestionTypeAnswersTag($questionType)
{
switch ($questionType) {
case 'match':
case 'ddmatch':
return 'match';
default:
return 'answer';
}
}
/**
* @param array Result of readMainQuestionsXml
*
* @return int Chamilo question type
*/
public function matchMoodleChamiloQuestionTypes($questionsValues)
{
$moodleQuestionType = $questionsValues['qtype'];
$questionOptions = $moodleQuestionType.'_values';
// Check <single> located in <plugin_qtype_multichoice_question><multichoice><single><single>
if (
'multichoice' === $moodleQuestionType &&
isset($questionsValues[$questionOptions]) &&
isset($questionsValues[$questionOptions]['single']) &&
1 === (int) $questionsValues[$questionOptions]['single']
) {
return UNIQUE_ANSWER;
}
switch ($moodleQuestionType) {
case 'multichoice':
return MULTIPLE_ANSWER;
case 'multianswer':
case 'match':
return FILL_IN_BLANKS;
case 'essay':
case 'shortanswer':
return FREE_ANSWER;
case 'truefalse':
return UNIQUE_ANSWER;
}
}
/**
* Fix moodle files that contains spaces.
*
* @param array $importedFiles
* @param string $text
*
* @return mixed
*/
public function fixPathInText($importedFiles, &$text)
{
if ($importedFiles) {
foreach ($importedFiles as $old => $new) {
// Ofaj fix moodle file names
// In some questions moodle text contains file with name like:
// Bild%20Check-In-Formular%20Ausfu%CC%88llen.jpg"
// rawurlencode function transforms '' (whitespace) to %20 and so on
$text = str_replace(rawurlencode($old), $new, $text);
}
}
return $text;
}
/**
* Process Moodle Answers to Chamilo.
*
* @param Exercise $exercise
* @param array $questionList
* @param string $questionType
* @param Question $questionInstance Question/Answer instance
* @param array $currentQuestion
* @param array $importedFiles
*
* @return int db response
*/
public function processAnswers(
$exercise,
$questionList,
$questionType,
$questionInstance,
$currentQuestion,
$importedFiles,
$sectionPath = ''
) {
switch ($questionType) {
case 'multichoice':
$objAnswer = new Answer($questionInstance->iid);
$questionWeighting = 0;
foreach ($questionList as $slot => $answer) {
$this->processMultipleAnswer(
$objAnswer,
$answer,
$slot + 1,
$questionWeighting,
$importedFiles,
$sectionPath
);
}
// saves the answers into the data base
$objAnswer->save();
// sets the total weighting of the question
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->save($exercise);
return true;
case 'multianswer':
$objAnswer = new Answer($questionInstance->iid);
$coursePath = api_get_course_path();
$placeholder = $this->replaceMoodleChamiloCoursePath($currentQuestion['questiontext'], $sectionPath);
$optionsValues = [];
foreach ($questionList as $slot => $subQuestion) {
$qtype = $subQuestion['qtype'];
$optionsValues[] = $this->processFillBlanks(
$objAnswer,
$qtype,
$subQuestion['plugin_qtype_'.$qtype.'_question'],
$placeholder,
$slot + 1
);
}
$answerOptionsWeight = '::';
$answerOptionsSize = '';
$questionWeighting = 0;
foreach ($optionsValues as $index => $value) {
$questionWeighting += $value['weight'];
$answerOptionsWeight .= $value['weight'].',';
$answerOptionsSize .= $value['size'].',';
}
$answerOptionsWeight = substr($answerOptionsWeight, 0, -1);
$answerOptionsSize = substr($answerOptionsSize, 0, -1);
$answerOptions = $answerOptionsWeight.':'.$answerOptionsSize.':0@';
$placeholder = $placeholder.PHP_EOL.$answerOptions;
// This is a minor trick to clean the question description that in a multianswer is the main placeholder
$questionInstance->updateDescription('');
// sets the total weighting of the question
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->save($exercise);
$this->fixPathInText($importedFiles, $placeholder);
// saves the answers into the data base
$objAnswer->createAnswer($placeholder, 0, '', 0, 1);
$objAnswer->save();
return true;
case 'match':
$objAnswer = new Answer($questionInstance->iid);
$placeholder = '';
$optionsValues = $this->processFillBlanks(
$objAnswer,
'match',
$questionList,
$placeholder,
0,
$sectionPath
);
$answerOptionsWeight = '::';
$answerOptionsSize = '';
$questionWeighting = 0;
foreach ($optionsValues as $index => $value) {
$questionWeighting += $value['weight'];
$answerOptionsWeight .= $value['weight'].',';
$answerOptionsSize .= $value['size'].',';
}
$answerOptionsWeight = substr($answerOptionsWeight, 0, -1);
$answerOptionsSize = substr($answerOptionsSize, 0, -1);
$answerOptions = $answerOptionsWeight.':'.$answerOptionsSize.':0@';
$placeholder = $placeholder.PHP_EOL.$answerOptions;
// sets the total weighting of the question
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->save($exercise);
// saves the answers into the database
$this->fixPathInText($importedFiles, $placeholder);
$objAnswer->createAnswer($placeholder, 0, '', 0, 1);
$objAnswer->save();
return true;
case 'ddmatch':
$questionWeighting = $currentQuestion['defaultmark'];
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->updateDescription(get_lang('ThisQuestionIsNotSupportedYet'));
$questionInstance->save($exercise);
return false;
case 'shortanswer':
case 'essay':
$questionWeighting = $currentQuestion['defaultmark'];
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->save($exercise);
return true;
case 'truefalse':
$objAnswer = new Answer($questionInstance->iid);
$questionWeighting = 0;
foreach ($questionList as $slot => $answer) {
$this->processTrueFalse(
$objAnswer,
$answer,
$slot + 1,
$questionWeighting,
$importedFiles,
$sectionPath
);
}
// saves the answers into the data base
$objAnswer->save();
// sets the total weighting of the question
$questionInstance->updateWeighting($questionWeighting);
$questionInstance->save($exercise);
return false;
default:
return false;
}
}
/**
* Process Chamilo Unique Answer.
*
* @param object $objAnswer
* @param array $answerValues
* @param int $position
* @param int $questionWeighting
* @param array $importedFiles
*
* @return int db response
*/
public function processUniqueAnswer(
$objAnswer,
$answerValues,
$position,
&$questionWeighting,
$importedFiles,
$sectionPath = ''
) {
$correct = (int) $answerValues['fraction'] ? (int) $answerValues['fraction'] : 0;
$answer = $answerValues['answertext'];
$comment = $answerValues['feedback'];
$weighting = $answerValues['fraction'];
$weighting = abs($weighting);
if ($weighting > 0) {
$questionWeighting += $weighting;
}
$goodAnswer = $correct ? true : false;
$this->fixPathInText($importedFiles, $answer);
$answer = $this->replaceMoodleChamiloCoursePath($answer, $sectionPath);
$comment = $this->replaceMoodleChamiloCoursePath($comment, $sectionPath);
$objAnswer->createAnswer(
$answer,
$goodAnswer,
$comment,
$weighting,
$position,
null,
null,
''
);
}
public function processMultipleAnswer(
Answer $objAnswer,
$answerValues,
$position,
&$questionWeighting,
$importedFiles,
$sectionPath = ''
) {
$answer = $answerValues['answertext'];
$comment = $answerValues['feedback'];
$weighting = $answerValues['fraction'];
//$weighting = abs($weighting);
if ($weighting > 0) {
$questionWeighting += $weighting;
}
$goodAnswer = $weighting > 0;
$this->fixPathInText($importedFiles, $answer);
$answer = $this->replaceMoodleChamiloCoursePath($answer, $sectionPath);
$comment = $this->replaceMoodleChamiloCoursePath($comment, $sectionPath);
$objAnswer->createAnswer(
$answer,
$goodAnswer,
$comment,
$weighting,
$position,
null,
null,
''
);
}
/**
* Process Chamilo True False.
*
* @param Answer $objAnswer
* @param array $answerValues
* @param int $position
* @param int $questionWeighting
* @param array $importedFiles
*
* @return int db response
*/
public function processTrueFalse(
$objAnswer,
$answerValues,
$position,
&$questionWeighting,
$importedFiles,
$sectionPath = ''
) {
$correct = isset($answerValues['fraction']) ? (int) $answerValues['fraction'] : 0;
$answer = $answerValues['answertext'];
$comment = $answerValues['feedback'];
$weighting = $answerValues['fraction'];
$weighting = abs($weighting);
if ($weighting > 0) {
$questionWeighting += $weighting;
}
$goodAnswer = $correct ? true : false;
$this->fixPathInText($importedFiles, $answer);
$answer = $this->replaceMoodleChamiloCoursePath($answer, $sectionPath);
$comment = $this->replaceMoodleChamiloCoursePath($comment, $sectionPath);
$objAnswer->createAnswer(
$answer,
$goodAnswer,
$comment,
$weighting,
$position
);
}
/**
* Process Chamilo FillBlanks.
*
* @param object $objAnswer
* @param array $questionType
* @param array $answerValues
* @param string $placeholder
* @param int $position
*
* @return int db response
*/
public function processFillBlanks(
$objAnswer,
$questionType,
$answerValues,
&$placeholder,
$position,
$sectionPath = ''
) {
switch ($questionType) {
case 'multichoice':
$optionsValues = [];
$correctAnswer = '';
$othersAnswer = '';
foreach ($answerValues as $answer) {
$correct = (int) $answer['fraction'];
if ($correct) {
$correctAnswer .= $answer['answertext'].'|';
$optionsValues['weight'] = $answer['fraction'];
$optionsValues['size'] = '200';
} else {
$othersAnswer .= $answer['answertext'].'|';
}
}
$currentAnswers = $correctAnswer.$othersAnswer;
$currentAnswers = '['.substr($currentAnswers, 0, -1).']';
$placeholder = str_replace("{#$position}", $currentAnswers, $placeholder);
return $optionsValues;
case 'shortanswer':
$optionsValues = [];
$correctAnswer = '';
foreach ($answerValues as $answer) {
$correct = (int) $answer['fraction'];
if ($correct) {
$correctAnswer .= $answer['answertext'];
$optionsValues['weight'] = $answer['fraction'];
$optionsValues['size'] = '200';
}
}
$currentAnswers = '['.$correctAnswer.']';
$placeholder = str_replace("{#$position}", $currentAnswers, $placeholder);
return $optionsValues;
case 'match':
$answers = [];
// Here first we need to extract all the possible answers
foreach ($answerValues as $slot => $answer) {
$answers[$slot] = $answer['answertext'];
}
// Now we set the order of the values matching the correct answer and set it to the first element
$optionsValues = [];
foreach ($answerValues as $slot => $answer) {
$correctAnswer = '';
$othersAnswers = '';
$correctAnswer .= $answer['answertext'].'|';
foreach ($answers as $other) {
if ($other !== $answer['answertext']) {
$othersAnswers .= $other.'|';
}
}
$optionsValues[$slot]['weight'] = 1;
$optionsValues[$slot]['size'] = '200';
$currentAnswers = htmlentities($correctAnswer.$othersAnswers);
$currentAnswers = '['.substr($currentAnswers, 0, -1).'] ';
$answer['questiontext'] = $this->replaceMoodleChamiloCoursePath($answer['questiontext'], $sectionPath);
$placeholder .= '<p> '.strip_tags($answer['questiontext']).' '.$currentAnswers.' </p>';
}
return $optionsValues;
default:
return false;
}
}
/**
* Updates the previous item ID for a given learning path item.
*
* @param int $currentItemId The ID of the current item.
* @param int $previousItemId The ID of the previous item to be set.
*/
public function updateLpItemPreviousId($currentItemId, $previousItemId)
{
$table = Database::get_course_table(TABLE_LP_ITEM);
$sql = "UPDATE $table SET previous_item_id = $previousItemId WHERE id = $currentItemId";
Database::query($sql);
}
/**
* Updates the next item ID for a given learning path item.
*
* @param int $previousItemId The ID of the previous item.
* @param int $currentItemId The ID of the current item to be set as next.
*/
public function updateLpItemNextId($previousItemId, $currentItemId)
{
$table = Database::get_course_table(TABLE_LP_ITEM);
$sql = "UPDATE $table SET next_item_id = $currentItemId WHERE id = $previousItemId";
Database::query($sql);
}
/**
* get All files associated with a question.
*
* @param $filesXml
*
* @return array
*/
public function getAllQuestionFiles($filesXml)
{
$moduleDoc = new DOMDocument();
$moduleRes = @$moduleDoc->loadXML($filesXml);
if (empty($moduleRes)) {
return [];
}
$allFiles = [];
$activities = $moduleDoc->getElementsByTagName('file');
foreach ($activities as $activity) {
$currentItem = [];
$thisIsAnInvalidItem = false;
if ($activity->childNodes->length) {
foreach ($activity->childNodes as $item) {
if ($item->nodeName == 'component' && $item->nodeValue == 'mod_resource') {
$thisIsAnInvalidItem = true;
}
if ($item->nodeName == 'component' && $item->nodeValue == 'mod_scorm') {
$currentItem['modscorm'] = true;
}
if ($item->nodeName == 'contenthash') {
$currentItem['contenthash'] = $item->nodeValue;
}
if ($item->nodeName == 'filename') {
$currentItem['filename'] = $item->nodeValue;
}
if ($item->nodeName == 'filesize') {
$currentItem['filesize'] = $item->nodeValue;
}
if ($item->nodeName == 'contextid') {
$currentItem['contextid'] = $item->nodeValue;
}
if ($item->nodeName == 'mimetype' && $item->nodeValue == 'document/unknown') {
$thisIsAnInvalidItem = true;
}
if ($item->nodeName == 'mimetype' && $item->nodeValue !== 'document/unknown') {
$currentItem['mimetype'] = $item->nodeValue;
}
}
}
if (!$thisIsAnInvalidItem) {
$allFiles[] = $currentItem;
}
}
return $allFiles;
}
/**
* Litle utility to delete the unuseful tags.
*
* @param $array
* @param $keys
*/
public function traverseArray(&$array, $keys)
{
foreach ($array as $key => &$value) {
if (is_array($value)) {
$this->traverseArray($value, $keys);
} else {
if (in_array($key, $keys)) {
unset($array[$key]);
}
}
}
}
/**
* Processes quiz questions organized by category.
*
* @param DOMDocument $questionsDoc The document containing the questions XML.
* @param DOMDocument $quizDoc The document containing the quiz XML.
*
* @return array Returns an array of processed questions filtered by category.
*/
protected function processByCategory($questionsDoc, $quizDoc)
{
$questionInstances = $quizDoc->getElementsByTagName('question_instance');
$questionSetReferences = [];
foreach ($questionInstances as $instance) {
$questionSetReference = $instance->getElementsByTagName('question_set_reference')->item(0);
if ($questionSetReference) {
$filterCondition = $questionSetReference->getElementsByTagName('filtercondition')->item(0)->nodeValue;
$filterCondition = json_decode($filterCondition, true);
if (isset($filterCondition['questioncategoryid'])) {
$categoryId = $filterCondition['questioncategoryid'];
$questionSetReferences[] = $categoryId;
}
}
}
if (empty($questionSetReferences)) {
return [];
}
$processedQuestions = [];
$questionsCount = 0;
foreach ($questionSetReferences as $categoryId) {
$xpath = new DOMXPath($questionsDoc);
$query = "//question_bank_entry[questioncategoryid='$categoryId']/question_version/question_versions/questions/question";
$entries = $xpath->query($query);
foreach ($entries as $question) {
if ($questionsCount >= count($questionInstances)) {
break;
}
$currentItem = $this->processQuestionV4($question);
if (!empty($currentItem)) {
$processedQuestions[] = $currentItem;
$questionsCount++;
}
}
}
return $processedQuestions;
}
/**
* Processes quiz questions based on question bank references.
*
* @param DOMDocument $questionsDoc The document containing the questions XML.
* @param DOMDocument $quizDoc The document containing the quiz XML.
*
* @return array Returns an array of processed questions from the question bank.
*/
protected function processByBankReference($questionsDoc, $quizDoc)
{
$questionInstances = $quizDoc->getElementsByTagName('question_instance');
$questionBankEntries = [];
foreach ($questionInstances as $instance) {
$questionReference = $instance->getElementsByTagName('question_reference')->item(0);
if ($questionReference) {
$questionBankEntryId = $questionReference->getElementsByTagName('questionbankentryid')->item(0)->nodeValue;
$questionBankEntries[] = $questionBankEntryId;
}
}
if (empty($questionBankEntries)) {
return [];
}
$processedQuestions = [];
$xpath = new DOMXPath($questionsDoc);
foreach ($questionBankEntries as $entryId) {
$query = "//question_bank_entry[@id='$entryId']/question_version/question_versions/questions/question";
$entries = $xpath->query($query);
foreach ($entries as $question) {
$processedQuestions[] = $this->processQuestionV4($question);
}
}
return $processedQuestions;
}
/**
* Processes individual quiz question data for Moodle version 4.
*
* @param DOMElement $question The DOM element representing a question in the XML.
*
* @return array Returns an associative array containing question data, including type, text, and answers.
*/
protected function processQuestionV4($question)
{
$currentItem = [
"questionid" => $question->getAttribute('id'),
"name" => '',
"questiontext" => '',
"generalfeedback" => '',
"defaultmark" => "1.0000000",
"penalty" => "0.3333333",
"qtype" => '',
"plugin_qtype_question" => [],
];
$questionType = '';
foreach ($question->childNodes as $item) {
switch ($item->nodeName) {
case 'name':
$currentItem['name'] = htmlspecialchars_decode($item->nodeValue);
break;
case 'questiontext':
$currentItem['questiontext'] = htmlspecialchars_decode($item->nodeValue);
break;
case 'generalfeedback':
$currentItem['generalfeedback'] = htmlspecialchars_decode($item->nodeValue);
break;
case 'qtype':
$questionType = $item->nodeValue;
$currentItem['qtype'] = $questionType;
break;
case 'plugin_qtype_'.$questionType.'_question':
$currentItem['plugin_qtype_'.$questionType.'_question'] = $this->processAnswersV4($item);
break;
}
}
return !empty($currentItem['name']) ? $currentItem : [];
}
/**
* Processes the answers for a given quiz question in Moodle version 4.
*
* @param DOMElement $item The DOM element containing answer data.
*
* @return array Returns an array of processed answers, each containing details like answer text and fraction.
*/
protected function processAnswersV4($item)
{
$answersList = [];
$answers = $item->getElementsByTagName('answer');
foreach ($answers as $i => $answer) {
$answerData = [
'answerid' => $answer->getAttribute('id'),
'answertext' => '',
'fraction' => '0.0000000',
];
foreach ($answer->childNodes as $properties) {
switch ($properties->nodeName) {
case 'answertext':
$answerData['answertext'] = htmlspecialchars_decode($properties->nodeValue);
break;
case 'fraction':
$answerData['fraction'] = $properties->nodeValue;
break;
case 'feedback':
$answerData['feedback'] = htmlspecialchars_decode($properties->nodeValue);
break;
}
}
$answersList[$i] = $answerData;
}
return $answersList;
}
/**
* Check if folder is empty or not.
*
* @param $dir
*
* @return bool
*/
private function isEmptyDir($dir)
{
$iterator = new FilesystemIterator($dir);
$isDirEmpty = !$iterator->valid();
return $isDirEmpty;
}
}
Zerion Mini Shell 1.0