class.ilQuestionPageParser.php

Go to the documentation of this file.

<?php
 
use ILIAS\Filesystem\Stream\Streams;
 
class ilQuestionPageParser extends ilSaxParser
{
    protected bool $in_properties;
    protected bool $in_glossary_definition = false;
    protected array $pg_mapping = [];
    protected array $mobs_with_int_links = [];
    protected bool $inside_code = false;
    protected string $content_type = '';
    public ilTree $tree;
    public array $cnt = [];                             // counts open elements
    public array $current_element = []; // store current element type
    public ?ilObjLearningModule $learning_module = null;        // current learning module
    public ?ilPageObject $page_object = null;           // current page object
    public ?ilLMPageObject $lm_page_object = null;
    public array $structure_objects = [];       // array of current structure objects
    public ?ilObjMediaObject $media_object = null;
    public ?object $current_object = null;      // at the time a LearningModule, PageObject or StructureObject
    public ?ilLMTree $lm_tree = null;
    public array $pg_into_tree = [];
    public array $st_into_tree = [];
    public array $container = [];
    public bool $in_page_object = false;        // are we currently within a PageObject? true/false
    public bool $in_media_object = false;
    public bool $in_file_item = false;
    public bool $in_glossary = false;
    public bool $in_map_area = false;
    public ?ilObjGlossary $glossary_object = null;
    public ?ilObjFile $file_item = null;
    public array $pages_to_parse = [];
    public array $mob_mapping = [];
    public array $file_item_mapping = [];
    public ?ilMediaItem $media_item = null;             // current media item
    public string $loc_type = '';                       // current location type
    public ?ilMapArea $map_area = null;                 // current map area
    public array $link_targets = [];            // stores all objects by import id
    public array $qst_mapping = [];
    protected array $glossary_term_map = [];
    protected ilLogger $log;
    protected ?ilGlossaryTerm $glossary_term = null;
    protected ?ilImportMapping $mapping = null;
    protected string $cur_qid = '';
    protected string $chr_data = '';
    protected bool $in_media_item = false;
 
    public function __construct(
        private readonly ilObject $content_object,
        string $xml_file,
        private readonly string $importdir
    ) {
        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());
        }
    }
 
    public function setHandlers($xml_parser): void
    {
        xml_set_element_handler($xml_parser, $this->handlerBeginTag(...), $this->handlerEndTag(...));
        xml_set_character_data_handler($xml_parser, $this->handlerCharacterData(...));
    }
 
    public function setImportMapping(?ilImportMapping $mapping = null): void
    {
        $this->mapping = $mapping;
    }
 
    public function startParsing(): void
    {
        $this->log->debug('start');
 
        parent::startParsing();
        $this->storeTree();
        $this->processPagesToParse();
        $this->copyFileItems();
    }
 
    public function storeTree(): 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']);
                    }
                }
            }
        }
    }
 
    public function processPagesToParse(): 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;
            }
        }
    }
 
    private function copyFileItems(): 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();
        }
    }
 
    public function setQuestionMapping(array $a_map): void
    {
        $this->qst_mapping = $a_map;
    }
 
    public function beginElement(string $a_name): 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;
    }
 
    public function endElement(string $a_name): void
    {
        $this->cnt[$a_name]--;
        unset($this->current_element[count($this->current_element) - 1]);
    }
 
    public function getCurrentElement(): string
    {
        return ($this->current_element[count($this->current_element) - 1] ?? '');
    }
 
    public function getOpenCount(string $a_name): int
    {
        if (isset($this->cnt[$a_name])) {
            return $this->cnt[$a_name];
        }
        return 0;
    }
 
    public function buildTag(
        string $type,
        string $name,
        array $attr = []
    ): string {
        $tag = '<';
 
        if ($type == 'end') {
            $tag .= '/';
        }
 
        $tag .= $name;
 
        if (is_array($attr)) {
            foreach ($attr as $k => $v) {
                $tag .= ' ' . $k . "='$v'";
            }
        }
 
        $tag .= '>';
 
        return $tag;
    }
 
    public function handlerBeginTag($a_xml_parser, string $a_name, array $a_attribs): void
    {
        switch ($a_name) {
            case 'ContentObject':
                $this->current_object = $this->content_object;
                if ($a_attribs['Type'] == 'Glossary') {
                    $this->glossary_object = $this->content_object;
                }
                break;
 
            case 'StructureObject':
                $lm = $this->content_object;
                $this->structure_objects[count($this->structure_objects)]
                    = new ilStructureObject($lm);
                $this->current_object = $this->structure_objects[count($this->structure_objects) - 1];
                $this->current_object->setLMId($this->content_object->getId());
                // new meta data handling: we create the structure
                // object already here, this should also create a
                // md entry
                $this->current_object->create(true);
                break;
 
            case 'PageObject':
                $this->in_page_object = true;
                $this->cur_qid = '';
                if ($this->content_type !== 'tst' && $this->content_type !== 'qpl') {
                    $lm = $this->content_object;
                    $this->lm_page_object = new ilLMPageObject($lm);
                    $this->page_object = new ilLMPage();
                    $this->lm_page_object->setLMId($this->content_object->getId());
                    $this->lm_page_object->assignPageObject($this->page_object);
                    $this->current_object = $this->lm_page_object;
                } else {
                    $this->page_object = new ilAssQuestionPage();
                }
                break;
 
            case 'PageAlias':
                throw new ilLMException('Page Alias not supported.');
 
            case 'MediaObject':
            case 'InteractiveImage':
                if ($a_name == 'MediaObject') {
                    $this->in_media_object = true;
                }
                $this->media_object = new ilObjMediaObject();
                $this->media_object->create(false, false);
                break;
 
            case 'MediaAlias':
                $this->media_object->setAlias(true);
                $this->media_object->setImportId($a_attribs['OriginId']);
                $this->mob_mapping[$this->media_object->getImportId()] = $this->media_object->getId();
                if (is_object($this->page_object)) {
                    $this->page_object->needsImportParsing(true);
                }
                break;
 
            case 'MediaItem':
            case 'MediaAliasItem':
                $this->in_media_item = true;
                $this->media_item = new ilMediaItem();
                $this->media_item->setPurpose($a_attribs['Purpose']);
                break;
 
            case 'Layout':
                if (is_object($this->media_object) && $this->in_media_object) {
                    $this->media_item->setWidth($a_attribs['Width'] ?? '');
                    $this->media_item->setHeight($a_attribs['Height'] ?? '');
                    $this->media_item->setHAlign($a_attribs['HorizontalAlign'] ?? '');
                }
                break;
 
            case 'Parameter':
                if (is_object($this->media_object) && $this->in_media_object) {
                    $this->media_item->setParameter($a_attribs['Name'], $a_attribs['Value']);
                }
                break;
 
            case 'MapArea':
                $this->in_map_area = true;
                $this->map_area = new ilMapArea();
                $this->map_area->setShape($a_attribs['Shape']);
                $this->map_area->setCoords($a_attribs['Coords']);
                $this->map_area->setHighlightMode($a_attribs['HighlightMode']);
                $this->map_area->setHighlightClass($a_attribs['HighlightClass']);
                break;
 
            case 'Glossary':
                $this->in_glossary = true;
                if ($this->content_object->getType() != 'glo') {
                    $this->glossary_object = new ilObjGlossary();
                    $this->glossary_object->setTitle('');
                    $this->glossary_object->setDescription('');
                    $this->glossary_object->create(true);
                    $this->glossary_object->createReference();
                    $parent = $this->tree->getParentNodeData($this->content_object->getRefId());
                    $this->glossary_object->putInTree($parent['child']);
                    $this->glossary_object->setPermissions($parent['child']);
                }
                $this->current_object = $this->glossary_object;
                break;
 
            case 'GlossaryItem':
                $this->glossary_term = new ilGlossaryTerm();
                $this->glossary_term->setGlossaryId($this->glossary_object->getId());
                $this->glossary_term->setLanguage($a_attribs['Language']);
                $this->glossary_term->setImportId($a_attribs['Id']);
                $parsed = $this->parseLinkTarget((string) $a_attribs['Id']);
                if (isset($parsed)) {
                    $this->link_targets[$a_attribs["Id"]] = $a_attribs['Id'];
                }
 
                // no break
            case 'Definition':
                $this->in_glossary_definition = true;
                $this->page_object = new ilGlossaryDefPage();
                $this->page_object->setParentId($this->glossary_term->getGlossaryId());
                $this->glossary_term->assignPageObject($this->page_object);
                $this->current_object = $this->glossary_term;
                // see bug #12465, we need to clear xml after creation, since it will be <PageObject></PageObject>
                // otherwise, and appendXML calls will lead to '<PageObject></PageObject><PageObject>....</PageObject>'
                $this->page_object->setXMLContent('');
                break;
 
            case 'FileItem':
                $this->in_file_item = true;
                $this->file_item = new ilObjFile();
                $this->file_item->setTitle('dummy');
                $this->file_item->setMode('filelist');
                if (is_object($this->page_object)) {
                    $this->page_object->needsImportParsing(true);
                }
                break;
 
            case 'Paragraph':
                if ($a_attribs['Characteristic'] == 'Code') {
                    $this->inside_code = true;
                }
                break;
 
            case 'Properties':
                $this->in_properties = true;
                break;
 
            case 'Property':
                if ($this->content_object->getType() == 'lm') {
                    switch ($a_attribs['Name']) {
                        case 'Layout':
                            $this->content_object->setLayout($a_attribs['Value']);
                            break;
 
                        case 'PageHeader':
                            $this->content_object->setPageHeader($a_attribs['Value']);
                            break;
 
                        case 'TOCMode':
                            $this->content_object->setTOCMode($a_attribs['Value']);
                            break;
 
                        case 'ActiveLMMenu':
                            $this->content_object->setActiveLMMenu(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'ActiveNumbering':
                            $this->content_object->setActiveNumbering(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'ActiveTOC':
                            $this->content_object->setActiveTOC(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'ActivePrintView':
                            $this->content_object->setActivePrintView(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'CleanFrames':
                            $this->content_object->setCleanFrames(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'PublicNotes':
                            $this->content_object->setPublicNotes(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'HistoryUserComments':
                            $this->content_object->setHistoryUserComments(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'Rating':
                            $this->content_object->setRating(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'RatingPages':
                            $this->content_object->setRatingPages(
                                ilUtil::yn2tf($a_attribs['Value'])
                            );
                            break;
 
                        case 'HeaderPage':
                            if ($a_attribs['Value'] != '') {
                                if ($this->pg_mapping[$a_attribs['Value']] > 0) {
                                    $this->content_object->setHeaderPage(
                                        $this->pg_mapping[$a_attribs['Value']]
                                    );
                                }
                            }
                            break;
 
                        case 'FooterPage':
                            if ($a_attribs['Value'] != '') {
                                if ($this->pg_mapping[$a_attribs['Value']] > 0) {
                                    $this->content_object->setFooterPage(
                                        $this->pg_mapping[$a_attribs['Value']]
                                    );
                                }
                            }
                            break;
 
                        case 'LayoutPerPage':
                            $this->content_object->setLayoutPerPage($a_attribs['Value']);
                            break;
 
                        case 'ProgressIcons':
                            $this->content_object->setProgressIcons($a_attribs['Value']);
                            break;
 
                        case 'StoreTries':
                            $this->content_object->setStoreTries($a_attribs['Value']);
                            break;
 
                        case 'RestrictForwardNavigation':
                            $this->content_object->setRestrictForwardNavigation($a_attribs['Value']);
                            break;
 
                        case 'DisableDefaultFeedback':
                            $this->content_object->setDisableDefaultFeedback($a_attribs['Value']);
                            break;
                    }
                }
                break;
 
                // Identifier
            case 'Identifier':
                if ($this->in_file_item) {
                    if (!isset($this->file_item_mapping[$a_attribs['Entry']])
                        || $this->file_item_mapping[$a_attribs['Entry']] === '') {
                        $this->file_item->create();
                        $this->file_item->setImportId($a_attribs['Entry']);
                        $this->file_item_mapping[$a_attribs['Entry']] = $this->file_item->getId();
                    }
                }
                if ($this->in_media_object) {
                    $mob_id = $this->mob_mapping[$a_attribs['Entry']];
 
                    // within learning module import, usually a media object
                    // has already been created with a media alias tag
                    if ($mob_id > 0) {
                        $this->media_object = new ilObjMediaObject($mob_id);
                    } else {    // in glossaries the media objects precede the definitions
                        // so we don't have an object already
                        $this->media_object = new ilObjMediaObject();
                        $this->media_object->create(false, false);
                        $this->mob_mapping[$a_attribs['Entry']]
                            = $this->media_object->getId();
                    }
                    $this->media_object->setImportId($a_attribs['Entry']);
                }
                break;
 
                // Internal Link
            case 'IntLink':
                if (is_object($this->page_object)) {
                    $this->page_object->setContainsIntLink(true);
                }
                if ($this->in_map_area) {
                    $this->map_area->setLinkType(IL_INT_LINK);
                    $this->map_area->setTarget($a_attribs['Target']);
                    $this->map_area->setType($a_attribs['Type']);
                    $this->map_area->setTargetFrame($a_attribs['TargetFrame']);
                    if (is_object($this->media_object)) {
                        $this->media_object->setContainsIntLink(true);
                    }
                }
                break;
 
                // External Link
            case 'ExtLink':
                if ($this->in_map_area) {
                    $this->map_area->setLinkType(IL_EXT_LINK);
                    $this->map_area->setHref($a_attribs['Href']);
                    $this->map_area->setExtTitle($a_attribs['Title']);
                }
                break;
 
                // Question
            case 'Question':
                $this->cur_qid = $a_attribs['QRef'];
                $this->page_object->setContainsQuestion(true);
                break;
 
            case 'Location':
                $this->loc_type = $a_attribs['Type'];
                break;
        }
        $this->beginElement($a_name);
 
        // append content to page xml content
        if (($this->in_page_object || $this->in_glossary_definition)
            && !$this->in_media_object) {
            if ($a_name == 'Definition') {
                $app_name = 'PageObject';
                $app_attribs = [];
            } else {
                $app_name = $a_name;
                $app_attribs = $a_attribs;
            }
 
            // change identifier entry of file items to new local file id
            if ($this->in_file_item && $app_name == 'Identifier') {
                $app_attribs['Entry'] = 'il__file_' . $this->file_item_mapping[$a_attribs['Entry']];
            }
 
            $this->page_object->appendXMLContent($this->buildTag('start', $app_name, $app_attribs));
        }
    }
 
    public function processMeta(): 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;
    }
 
 
    public function handlerEndTag($a_xml_parser, string $a_name): 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 = '';
    }
 
    public function handlerCharacterData($a_xml_parser, string $a_data): 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;
            }
        }
    }
 
    public function getGlossaryTermMap(): array
    {
        return $this->glossary_term_map;
    }
 
    private function parseLinkTarget(string $identifier): ?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]
        ];
    }
}