Legacy Content Object Parser. More...

Inheritance diagram for ilQuestionPageParser:

Collaboration diagram for ilQuestionPageParser:

Public Member Functions
	__construct (private readonly ilObject $content_object, string $xml_file, private readonly string $importdir)

	setHandlers ($xml_parser)

	setImportMapping (?ilImportMapping $mapping=null)

	startParsing ()

	storeTree ()
	insert StructureObjects and PageObjects into tree More...

	processPagesToParse ()
	parse pages that contain files, mobs and/or internal links More...

	setQuestionMapping (array $a_map)
	set question import ident to pool/test question id mapping More...

	beginElement (string $a_name)

	endElement (string $a_name)

	getCurrentElement ()

	getOpenCount (string $a_name)

	buildTag (string $type, string $name, array $attr=[])

	processMeta ()

	handlerEndTag ($a_xml_parser, string $a_name)

	handlerCharacterData ($a_xml_parser, string $a_data)

	getGlossaryTermMap ()

Public Member Functions inherited from ilSaxParser
	__construct (?string $path_to_file='', ?bool $throw_exception=false)

	setXMLContent (string $a_xml_content)

	getXMLContent ()

	getInputType ()

	startParsing ()
	stores xml data in array More...

	createParser ()

	setHandlers ($a_xml_parser)

	parse ($a_xml_parser, $a_fp=null)

Data Fields
ilTree	$tree

array	$cnt = []

array	$current_element = []

ilObjLearningModule	$learning_module = null

ilPageObject	$page_object = null

ilLMPageObject	$lm_page_object = null

array	$structure_objects = []

ilObjMediaObject	$media_object = null

object	$current_object = null

ilLMTree	$lm_tree = null

array	$pg_into_tree = []

array	$st_into_tree = []

array	$container = []

bool	$in_page_object = false

bool	$in_media_object = false

bool	$in_file_item = false

bool	$in_glossary = false

bool	$in_map_area = false

ilObjGlossary	$glossary_object = null

ilObjFile	$file_item = null

array	$pages_to_parse = []

array	$mob_mapping = []

array	$file_item_mapping = []

ilMediaItem	$media_item = null

string	$loc_type = ''

ilMapArea	$map_area = null

array	$link_targets = []

array	$qst_mapping = []

Data Fields inherited from ilSaxParser
string	$xml_file

bool	$throw_exception = false

Protected Attributes
bool	$in_properties

bool	$in_glossary_definition = false

array	$pg_mapping = []

array	$mobs_with_int_links = []

bool	$inside_code = false

string	$content_type = ''

array	$glossary_term_map = []

ilLogger	$log

ilGlossaryTerm	$glossary_term = null

ilImportMapping	$mapping = null

string	$cur_qid = ''

string	$chr_data = ''

bool	$in_media_item = false

Protected Attributes inherited from ilSaxParser
ilLanguage	$lng = null

Private Member Functions
	copyFileItems ()
	copy files of file items More...

	parseLinkTarget (string $identifier)
	Parse a string the get the elements of a link target Return null if the string is not a link target. More...

Additional Inherited Members
Protected Member Functions inherited from ilSaxParser
	openXMLFile ()

	handleError (string $message)

	setThrowException (bool $throw_exception)

Detailed Description

Legacy Content Object Parser.

Author: Alexander Killing killi.nosp@m.ng@l.nosp@m.eifos.nosp@m..de

Deprecated:: use COPage dependency to export/import COPages instead

Definition at line 27 of file class.ilQuestionPageParser.php.

Constructor & Destructor Documentation

◆ __construct()

ilQuestionPageParser::__construct	(	private readonly ilObject	$content_object,
		string	$xml_file,
		private readonly string	$importdir
	)

Definition at line 77 of file class.ilQuestionPageParser.php.

References $DIC, ilSaxParser\$lng, $tree, ILIAS\GlobalScreen\Provider\__construct(), ilLoggerFactory\getLogger(), and ILIAS\Repository\lng().

       {
         global $DIC;
         $lng = $DIC->language();
         $tree = $DIC->repositoryTree();
 
         $this->log = ilLoggerFactory::getLogger('lm');
 
         parent::__construct($xml_file);
         $this->cnt = [];
         $this->current_element = [];
         $this->structure_objects = [];
         $this->st_into_tree = [];
         $this->pg_into_tree = [];
         $this->pages_to_parse = [];
         $this->mobs_with_int_links = [];
         $this->mob_mapping = [];
         $this->file_item_mapping = [];
         $this->pg_mapping = [];
         $this->link_targets = [];
         $this->lng = $lng;
         $this->tree = $tree;
         $this->inside_code = false;
         $this->qst_mapping = [];
         $this->content_type = $this->content_object->getType();
 
         if ($this->content_type !== 'tst' && $this->content_type !== 'qpl') {
             $this->lm_tree = new ilLMTree($this->content_object->getId());
         }
     }

Here is the call graph for this function:

Member Function Documentation

◆ beginElement()

ilQuestionPageParser::beginElement ( string $a_name )

Definition at line 293 of file class.ilQuestionPageParser.php.

Referenced by buildTag().

                                                 : void
     {
         if (!isset($this->status['$a_name'])) {
             $this->cnt[$a_name] = 1;
         } else {
             $this->cnt[$a_name]++;
         }
         $this->current_element[count($this->current_element)] = $a_name;
     }

Here is the caller graph for this function:

◆ buildTag()

ilQuestionPageParser::buildTag	(	string	$type,
		string	$name,
		array	$attr = `[]`
	)

Definition at line 322 of file class.ilQuestionPageParser.php.

References $glossary_object, $glossary_term, $lm_page_object, beginElement(), IL_EXT_LINK, IL_INT_LINK, parseLinkTarget(), and ilUtil\yn2tf().

Referenced by handlerEndTag().

      : string {
         $tag = '<';
 
         if ($type == 'end') {
             $tag .= '/';
         }
 
         $tag .= $name;
 
         if (is_array($attr)) {
             foreach ($attr as $k => $v) {
                 $tag .= ' ' . $k . "='$v'";
             }
         }
 
         $tag .= '>';
 
         return $tag;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyFileItems()

ilQuestionPageParser::copyFileItems ( )

private

copy files of file items

Definition at line 262 of file class.ilQuestionPageParser.php.

Referenced by startParsing().

                                     : void
     {
         foreach ($this->file_item_mapping as $origin_id => $file_id) {
             if (empty($origin_id)) {
                 continue;
             }
             $obj_dir = $origin_id;
             $source_dir = $this->importdir . DIRECTORY_SEPARATOR . 'objects' . DIRECTORY_SEPARATOR . $obj_dir;
 
             $file_obj = new ilObjFile($file_id, false);
             if (is_dir($source_dir)) {
                 $files = scandir($source_dir, SCANDIR_SORT_DESCENDING);
                 if ($files !== false && $files !== [] && is_file($source_dir . '/' . $files[0])) {
                     $file = fopen($source_dir . '/' . $files[0], 'rb');
                     $file_stream = Streams::ofResource($file);
                     $file_obj->appendStream($file_stream, $files[0]);
                 }
             }
             $file_obj->update();
         }
     }

Here is the caller graph for this function:

◆ endElement()

ilQuestionPageParser::endElement ( string $a_name )

Definition at line 303 of file class.ilQuestionPageParser.php.

Referenced by handlerEndTag().

                                               : void
     {
         $this->cnt[$a_name]--;
         unset($this->current_element[count($this->current_element) - 1]);
     }

Here is the caller graph for this function:

◆ getCurrentElement()

ilQuestionPageParser::getCurrentElement ( )

Definition at line 309 of file class.ilQuestionPageParser.php.

Referenced by handlerCharacterData().

                                        : string
     {
         return ($this->current_element[count($this->current_element) - 1] ?? '');
     }

Here is the caller graph for this function:

◆ getGlossaryTermMap()

ilQuestionPageParser::getGlossaryTermMap ( )

Returns: mixed[]

Definition at line 1049 of file class.ilQuestionPageParser.php.

References $glossary_term_map.

                                         : array
     {
         return $this->glossary_term_map;
     }

◆ getOpenCount()

ilQuestionPageParser::getOpenCount ( string $a_name )

Definition at line 314 of file class.ilQuestionPageParser.php.

                                                 : int
     {
         if (isset($this->cnt[$a_name])) {
             return $this->cnt[$a_name];
         }
         return 0;
     }

◆ handlerCharacterData()

ilQuestionPageParser::handlerCharacterData	(		$a_xml_parser,
		string	$a_data
	)

Definition at line 1009 of file class.ilQuestionPageParser.php.

References getCurrentElement().

Referenced by setHandlers().

                                                                        : void
     {
         // the parser converts '&gt;' to '>' and '&lt;' to '<'
         // in character data, but we don't want that, because it's the
         // way we mask user html in our content, so we convert back...
 
         $a_data = str_replace('<', '&lt;', $a_data);
         $a_data = str_replace('>', '&gt;', $a_data);
 
 
         // DELETE WHITESPACES AND NEWLINES OF CHARACTER DATA
         $a_data = preg_replace('/\n/', '', $a_data);
         if (!$this->inside_code) {
             $a_data = preg_replace('/\t+/', '', $a_data);
         }
 
         $this->chr_data .= $a_data;
 
         if (!empty($a_data) || $a_data === '0') {
             // append all data to page, if we are within PageObject,
             // but not within MetaData or MediaObject
             if (($this->in_page_object || $this->in_glossary_definition)
                 && !$this->in_media_object) {
                 $this->page_object->appendXMLContent($a_data);
             }
 
             switch ($this->getCurrentElement()) {
                 case 'IntLink':
                 case 'ExtLink':
                     if ($this->in_map_area) {
                         $this->map_area->appendTitle($a_data);
                     }
                     break;
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handlerEndTag()

ilQuestionPageParser::handlerEndTag	(		$a_xml_parser,
		string	$a_name
	)

Definition at line 704 of file class.ilQuestionPageParser.php.

References $cur_qid, buildTag(), endElement(), IL_MODE_ALIAS, ILIAS\Repository\int(), and ilUtil\parseImportId().

Referenced by setHandlers().

                                                                 : void
     {
         // append content to page xml content
         if (($this->in_page_object || $this->in_glossary_definition)
             && !$this->in_media_object) {
             $app_name = ($a_name == 'Definition')
                 ? 'PageObject'
                 : $a_name;
             $this->page_object->appendXMLContent($this->buildTag('end', $app_name));
         }
 
         switch ($a_name) {
             case 'StructureObject':
                 unset($this->structure_objects[count($this->structure_objects) - 1]);
                 break;
 
             case 'PageObject':
                 $this->in_page_object = false;
                 if ($this->content_type != 'tst' && $this->content_type != 'qpl') {
                     //if (!$this->lm_page_object->isAlias()) {
                     $this->page_object->updateFromXML();
                     $this->pg_mapping[$this->lm_page_object->getImportId()]
                             = $this->lm_page_object->getId();
 
                     if ($this->mapping instanceof ilImportMapping) {
                         $import_id_parsed = ilUtil::parseImportId($this->lm_page_object->getImportId());
                         if ($import_id_parsed['type'] == 'pg') {
                             $this->mapping->addMapping(
                                 'components/ILIAS/LearningModule',
                                 'pg',
                                 $import_id_parsed['id'],
                                 $this->lm_page_object->getId()
                             );
                         }
                     }
 
                     // collect pages with internal links
                     if ($this->page_object->containsIntLink()) {
                         $this->pages_to_parse['lm:' . $this->page_object->getId()] = 'lm:' . $this->page_object->getId();
                     }
 
                     // collect pages with mobs or files
                     if ($this->page_object->needsImportParsing()) {
                         $this->pages_to_parse['lm:' . $this->page_object->getId()] = 'lm:' . $this->page_object->getId();
                     }
 
                     // collect pages with questions
                     if ($this->page_object->getContainsQuestion()) {
                         $this->pages_to_parse['lm:' . $this->page_object->getId()] = 'lm:' . $this->page_object->getId();
                     }
                     //}
                 } else {
                     $xml = $this->page_object->getXMLContent();
                     if ($this->cur_qid != '') {
                         $ids = $this->qst_mapping[$this->cur_qid] ?? ['pool' => 0, 'test' => 0];
                         if ($ids['pool'] > 0) {
                             // question pool question
                             $page = new ilAssQuestionPage($ids['pool']);
                             $xmlcontent = str_replace(
                                 $this->cur_qid,
                                 'il__qst_' . $ids['pool'],
                                 $xml
                             );
                             $page->setXMLContent($xmlcontent);
                             $page->updateFromXML();
                             if ($this->page_object->needsImportParsing()) {
                                 $this->pages_to_parse['qpl:' . $page->getId()] = 'qpl:' . $page->getId();
                             }
                             unset($page);
                         }
                         if ($ids['test'] > 0) {
                             // test question
                             $page = new ilAssQuestionPage($ids['test']);
                             $xmlcontent = str_replace(
                                 $this->cur_qid,
                                 'il__qst_' . $ids['test'],
                                 $xml
                             );
                             $page->setXMLContent($xmlcontent);
                             $page->updateFromXML();
                             if ($this->page_object->needsImportParsing()) {
                                 $this->pages_to_parse['qpl:' . $page->getId()] = 'qpl:' . $page->getId();
                             }
                             unset($page);
                         }
                     }
                 }
 
                 // if we are within a structure object: put page in tree
                 $cnt = count($this->structure_objects);
                 if ($cnt > 0) {
                     $parent_id = $this->structure_objects[$cnt - 1]->getId();
                     $this->pg_into_tree[$parent_id][] = ['type' => 'pg', 'id' => $this->lm_page_object->getId()];
                 }
 
                 unset($this->page_object);
                 unset($this->lm_page_object);
                 unset($this->container[count($this->container) - 1]);
                 break;
 
             case 'MediaObject':
             case 'InteractiveImage':
                 if ($a_name == 'MediaObject') {
                     $this->in_media_object = false;
                 }
 
                 if (empty($this->mob_mapping[$this->media_object->getImportId()])) {
                     // create media object
                     // media items are saves for mobs outside of
                     // pages only
                     $this->media_object->create(false, false);
 
                     // collect mobs with internal links
                     if ($this->media_object->containsIntLink()) {
                         $this->mobs_with_int_links[] = $this->media_object->getId();
                     }
 
                     $this->mob_mapping[$this->media_object->getImportId()]
                             = $this->media_object->getId();
                 } else {
                     // get the id from mapping
                     $this->media_object->setId($this->mob_mapping[$this->media_object->getImportId()]);
 
                     // update 'real' (no alias) media object
                     // (note: we overwrite any data from the media object
                     // created by an MediaAlias, only the data of the real
                     // object is stored in db separately; data of the
                     // MediaAliases are within the page XML
                     if (!$this->media_object->isAlias()) {
                         // now the media items are saved within the db
                         $this->media_object->update();
 
                         // collect mobs with internal links
                         if ($this->media_object->containsIntLink()) {
                             $this->mobs_with_int_links[] = $this->media_object->getId();
                         }
                     }
                 }
 
                 // append media alias to page, if we are in a page
                 if ($this->in_page_object || $this->in_glossary_definition) {
                     if ($a_name != 'InteractiveImage') {
                         $this->page_object->appendXMLContent($this->media_object->getXML(IL_MODE_ALIAS));
                     }
                 }
 
                 break;
 
             case 'MediaAliasItem':
                 $this->in_media_item = false;
                 $this->media_object->addMediaItem($this->media_item);
                 break;
             case 'MediaItem':
                 $this->in_media_item = false;
                 $import_dir = $this->importdir . DIRECTORY_SEPARATOR . 'objects' . DIRECTORY_SEPARATOR . $this->media_object->getImportId();
                 if (!file_exists($import_dir)
                     || !is_dir($import_dir)) {
                     $this->media_object->addMediaItem($this->media_item);
                     break;
                 }
 
                 $dir_handle = opendir($import_dir);
                 while (($file = readdir($dir_handle)) !== false) {
                     if ($file !== $this->media_item->getLocation()) {
                         continue;
                     }
 
                     $this->media_object->addMediaItemFromLocalFile(
                         $this->media_item->getPurpose(),
                         $import_dir . DIRECTORY_SEPARATOR . $file,
                         $file
                     );
                     break;
                 }
                 closedir($dir_handle);
                 break;
 
             case 'MapArea':
                 $this->in_map_area = false;
                 $this->media_item->addMapArea($this->map_area);
                 break;
 
             case 'Properties':
                 $this->in_properties = false;
                 if ($this->content_object->getType() == 'lm') {
                     $this->content_object->update();
                 }
                 break;
 
             case 'FileItem':
                 $this->in_file_item = false;
                 // only update new file items
                 if ($this->file_item->getImportId()) {
                     $this->file_item->update();
                 }
                 break;
 
 
             case 'Table':
                 unset($this->container[count($this->container) - 1]);
                 break;
 
             case 'Glossary':
                 $this->in_glossary = false;
                 break;
 
             case 'GlossaryTerm':
                 $term = trim($this->chr_data);
                 $term = str_replace('&lt;', '<', $term);
                 $term = str_replace('&gt;', '>', $term);
                 $this->glossary_term->setTerm($term);
                 $this->glossary_term->create();
                 $iia = explode('_', $this->glossary_term->getImportId());
                 $this->glossary_term_map[(int) $iia[count($iia) - 1]] = $this->glossary_term->getId();
                 break;
 
             case 'Paragraph':
                 $this->inside_code = false;
                 break;
 
             case 'Definition':
                 $this->in_glossary_definition = false;
                 $this->page_object->updateFromXML();
                 $this->page_object->buildDom();
                 $this->glossary_term->setShortText($this->page_object->getFirstParagraphText());
                 $this->glossary_term->update();
                 if ($this->page_object->containsIntLink()) {
                     $this->pages_to_parse['term:' . $this->page_object->getId()] = 'term:' . $this->page_object->getId();
                 }
                 if ($this->page_object->needsImportParsing()) {
                     $this->pages_to_parse['term:' . $this->page_object->getId()] = 'term:' . $this->page_object->getId();
                 }
                 break;
 
             case 'Format':
                 if ($this->in_media_item) {
                     $this->media_item->setFormat(trim($this->chr_data));
                 }
                 break;
 
             case 'Title':
                 if ($this->in_media_object) {
                     $this->media_object->setTitle(trim($this->chr_data));
                 }
                 break;
 
             case 'Description':
             case 'Language':
                 break;
 
             case 'Caption':
                 if ($this->in_media_object) {
                     $this->media_item->setCaption(trim($this->chr_data));
                 }
                 break;
 
             case 'TextRepresentation':
                 if ($this->in_media_object) {
                     $this->media_item->setTextRepresentation(trim($this->chr_data));
                 }
                 break;
 
                 // Location
             case 'Location':
                 // TODO: adapt for files in 'real' subdirectories
                 if ($this->in_media_item) {
                     $this->media_item->setLocationType($this->loc_type);
                     if ($this->loc_type == 'Reference') {
                         $this->media_item->setLocation(str_replace('&', '&amp;', trim($this->chr_data)));
                     } else {
                         $this->media_item->setLocation(trim($this->chr_data));
                     }
                 }
                 if ($this->in_file_item) {
                     // set file name from xml file
                     $this->file_item->setFileName(trim($this->chr_data));
 
                     // special handling for file names with special characters
                     // (e.g. '&gt;')
                     if ($this->file_item->getType() == 'file' &&
                         is_int(strpos($this->chr_data, '&')) &&
                         is_int(strpos($this->chr_data, ';'))) {
                         $source_dir = $this->importdir . DIRECTORY_SEPARATOR . 'objects' . DIRECTORY_SEPARATOR .
                             $this->file_item->getImportId();
 
                         // read 'physical' file name from directory
                         if ($dir = opendir($source_dir)) {
                             while (false !== ($file = readdir($dir))) {
                                 if ($file != '.' && $file != '..') {
                                     $this->file_item->setFileName($file);
                                 }
                             }
                             closedir($dir);
                         }
                     }
 
                     // set file item title
                     $this->file_item->setTitle(trim($this->chr_data));
                 }
                 break;
         }
         $this->endElement($a_name);
         $this->chr_data = '';
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseLinkTarget()

ilQuestionPageParser::parseLinkTarget ( string $identifier )

private

Parse a string the get the elements of a link target Return null if the string is not a link target.

Returns: array{target_inst: int, target_type: string, target_id: int}|null

Definition at line 1059 of file class.ilQuestionPageParser.php.

References ILIAS\Repository\int(), and null.

Referenced by buildTag(), and processPagesToParse().

                                                         : ?array
     {
         $link_arr = explode('_', $identifier);
 
         if (count($link_arr) !== 4
             || $link_arr[0] !== 'il'
             || !is_numeric($link_arr[1])
             || !is_numeric($link_arr[3])
         ) {
             return null;
         }
 
         return [
           'target_inst' => (int) $link_arr[1],
           'target_type' => (string) $link_arr[2],
           'target_id' => (int) $link_arr[3]
         ];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processMeta()

ilQuestionPageParser::processMeta ( )

Definition at line 690 of file class.ilQuestionPageParser.php.

References $in_glossary_definition.

                                  : bool
     {
         // do not process second meta block in (ilias3) glossaries
         // which comes right after the 'Glossary' tag
         if ($this->content_object->getType() == 'glo' &&
             $this->in_glossary && !$this->in_media_object
             && !$this->in_glossary_definition) {
             return false;
         }
 
         return true;
     }

◆ processPagesToParse()

ilQuestionPageParser::processPagesToParse ( )

parse pages that contain files, mobs and/or internal links

Definition at line 174 of file class.ilQuestionPageParser.php.

References ilPageObject\_exists(), ilInternalLink\_getSourcesOfTarget(), ilMediaItem\_resolveMapAreaLinks(), ilPageObject\buildDom(), ilPageObjectFactory\getInstance(), assQuestion\instantiateQuestion(), null, parseLinkTarget(), ilPageObject\resolveIntLinks(), and ilPageObject\update().

Referenced by startParsing().

                                          : void
     {
         // outgoin internal links
         foreach ($this->pages_to_parse as $page_id) {
             $page_arr = explode(':', $page_id);
             $page_obj = null;
             switch ($page_arr[0]) {
                 case 'lm':
                     switch ($this->content_object->getType()) {
                         case 'lm':
                             $page_obj = new ilLMPage($page_arr[1]);
                             break;
 
                         default:
                             die('Unknown content type ' . $this->content_object->getType());
                     }
 
                     break;
 
                 case 'term':
                     $page_obj = new ilGlossaryDefPage($page_arr[1]);
                     break;
 
                 case 'qpl':
                     $page_obj = new ilAssQuestionPage($page_arr[1]);
                     break;
             }
             $page_obj->buildDom();
             $page_obj->resolveIntLinks();
             $page_obj->resolveIIMMediaAliases($this->mob_mapping);
             if ($this->content_type == 'lm') {
                 $page_obj->resolveQuestionReferences($this->qst_mapping);
             }
             $page_obj->update(false);
 
             if ($page_arr[0] == 'term') {
                 $term = new ilGlossaryTerm($page_arr[1]);
                 $term->updateShortText();
             }
 
             unset($page_obj);
         }
 
         foreach ($this->mobs_with_int_links as $mob_id) {
             ilMediaItem::_resolveMapAreaLinks($mob_id);
         }
 
         $done = [];
         foreach ($this->link_targets as $link_target) {
             $parsed = $this->parseLinkTarget((string) $link_target);
             if (!isset($parsed)) {
                 continue;
             }
             //echo "doin link target:".$link_target.":<br>";
             $sources = ilInternalLink::_getSourcesOfTarget(
                 $parsed['target_type'],
                 $parsed['target_id'],
                 $parsed['target_inst']
             );
             foreach ($sources as $key => $source) {
                 if (in_array($key, $done)) {
                     continue;
                 }
                 $type_arr = explode(':', $source['type']);
 
                 // content object pages
                 if ($type_arr[1] == 'pg') {
                     if (ilPageObject::_exists($type_arr[0], $source['id'])) {
                         $page_object = ilPageObjectFactory::getInstance($type_arr[0], $source['id']);
                         $page_object->buildDom();
                         $page_object->resolveIntLinks();
                         $page_object->update();
                         unset($page_object);
                     }
                 }
 
                 // eventually correct links in questions to learning modules
                 if ($type_arr[0] === 'qst') {
                     assQuestion::instantiateQuestion($source['id'])->resolveSuggestedSolutionLinks();
                 }
                 $done[$key] = $key;
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setHandlers()

ilQuestionPageParser::setHandlers ( $xml_parser )

Parameters

resource $a_xml_parser

Definition at line 114 of file class.ilQuestionPageParser.php.

References handlerCharacterData(), and handlerEndTag().

                                             : void
     {
         xml_set_element_handler($xml_parser, $this->handlerBeginTag(...), $this->handlerEndTag(...));
         xml_set_character_data_handler($xml_parser, $this->handlerCharacterData(...));
     }

Here is the call graph for this function:

◆ setImportMapping()

ilQuestionPageParser::setImportMapping ( ?ilImportMapping $mapping = null )

Definition at line 120 of file class.ilQuestionPageParser.php.

References $mapping.

                                                                       : void
     {
         $this->mapping = $mapping;
     }

◆ setQuestionMapping()

ilQuestionPageParser::setQuestionMapping ( array $a_map )

set question import ident to pool/test question id mapping

Parameters

mixed[] $a_map

Definition at line 288 of file class.ilQuestionPageParser.php.

                                                     : void
     {
         $this->qst_mapping = $a_map;
     }

◆ startParsing()

ilQuestionPageParser::startParsing ( )

Definition at line 125 of file class.ilQuestionPageParser.php.

References copyFileItems(), processPagesToParse(), and storeTree().

                                   : void
     {
         $this->log->debug('start');
 
         parent::startParsing();
         $this->storeTree();
         $this->processPagesToParse();
         $this->copyFileItems();
     }

Here is the call graph for this function:

◆ storeTree()

ilQuestionPageParser::storeTree ( )

insert StructureObjects and PageObjects into tree

Definition at line 138 of file class.ilQuestionPageParser.php.

References $log, and ilLogger\write().

Referenced by startParsing().

                                : void
     {
         $ilLog = $this->log;
 
         foreach ($this->st_into_tree as $st) {
             $this->lm_tree->insertNode($st['id'], $st['parent']);
             if (is_array($this->pg_into_tree[$st['id']])) {
                 foreach ($this->pg_into_tree[$st['id']] as $pg) {
                     $pg_id = 0;
                     switch ($pg['type']) {
                         case 'pg_alias':
                             if ($this->pg_mapping[$pg['id']] == '') {
                                 $ilLog->write('LM Import: No PageObject for PageAlias ' .
                                               $pg['id'] . ' found! (Please update export installation to ILIAS 3.3.0)');
 
                                 // Jump two levels up. First level is switch
                                 continue 2;
                             }
                             $pg_id = $this->pg_mapping[$pg['id']];
                             break;
 
                         case 'pg':
                             $pg_id = $pg['id'];
                             break;
                     }
                     if (!$this->lm_tree->isInTree($pg_id)) {
                         $this->lm_tree->insertNode($pg_id, $st['id']);
                     }
                 }
             }
         }
     }