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 ()
	stores xml data in array More...

	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.

      {
        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());
        }
    }

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

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.

                                                : 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;
    }

◆ buildTag()

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

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

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

◆ copyFileItems()

ilQuestionPageParser::copyFileItems ( )

private

copy files of file items

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

                                    : 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();
        }
    }

Referenced by startParsing().

Here is the caller graph for this function:

◆ endElement()

ilQuestionPageParser::endElement ( string $a_name )

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

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

◆ getCurrentElement()

ilQuestionPageParser::getCurrentElement ( )

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

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

◆ getGlossaryTermMap()

ilQuestionPageParser::getGlossaryTermMap ( )

Returns: mixed[]

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

                                        : 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.

                                                                       : 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;
            }
        }
    }

Referenced by setHandlers().

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.

                                                                : 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 = '';
    }

References IL_MODE_ALIAS, ILIAS\Repository\int(), and ilUtil\parseImportId().

Referenced by setHandlers().

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.

                                                        : ?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]
        ];
    }

References ILIAS\Repository\int().

Referenced by processPagesToParse().

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.

                                 : 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.

                                         : 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;
            }
        }
    }

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

Referenced by startParsing().

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

Reimplemented from ilSaxParser.

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

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

References handlerCharacterData(), and handlerEndTag().

Here is the call graph for this function:

◆ setImportMapping()

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

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

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

References $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 ( )

stores xml data in array

Exceptions

ilSaxParserException

Reimplemented from ilSaxParser.

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

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

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

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.

                               : 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']);
                    }
                }
            }
        }
    }