Page.php

gehe zur Dokumentation dieser Datei

<?php
require_once 'base/Page_Iterator.php';
require_once 'base/Mediapool.php';
 
class Page_Exception extends Exception {
    const  ROOT_PROTECTION = 1; 
    const  FILE_REPLACE = 4; 
    const  METHOD_NOT_FOUND = 8; 
}
 
class Page {
    const  CACHE_BROWSER = 1; 
    const  CACHE_PROXY = 2; 
    const  CACHE_SERVER = 4; 
    const  ACTIVE_FLAG = 0; 
    const  INACTIVE_FLAG = 1; 
    const  RELEASE_FLAG = 2; 
    const  IDENTITY_SEPARATOR = '.'; 
    public  $field; 
    public  $extra; 
    public  $message = ''; 
    private  $_site; 
    private  $tableSuffix = ''; 
    public   $mainOrient = 'center'; 
    protected  $typeInfo = array(); 
    public  $_updatedLinkLanguages; 
    public  $archiveOnly = false; 
    public  $originalType = ''; 
    private  $lastChangeDate = ''; 
    private  $frontendActive = false; 
    private  $editFields = array(); 
    public  $conf = array(); 
    private static  $nextIds = array(); 
    function __construct(Site $site, $field, $archive = false) {
        $this->_site = $site;
        $this->field = $field;
        $this->extra = $this->field['extra']?unserialize($this->field['extra']):array();
        $this->lastChangeDate = $this->field['m_date'];
        $this->originalType = $this->field['type'];
 
        if ($_REQUEST['c_date'] && $this->field['id']) { // Einen Archiveintrag holen.
            $c_date = $_REQUEST['c_date'];
            if (is_numeric($c_date)) {
                $c_date = date('Y-m-d H:i:s', $_REQUEST['c_date']);
            }
            $db = new_db_connection(array(
                'table' => $this->_site->pageTable.'_v',
                'where' => "id=".$this->field['id']." AND m_date<=:cdate",
                'order' => 'm_date DESC',
                'limit' => 1,
                'bind'  => array('cdate' => $c_date)
            ));
            if ($db->nextRecord()) {
                $this->field = $db->Record;
                $this->extra = $db->Record['extra']?unserialize($db->Record['extra']):array();
            }
 
            $this->lastChangeDate = $this->field['m_date'];
        } elseif (
            $_GET['preview']
            && $_REQUEST['id'] == $field['id']
            && $_REQUEST['site'] == $site->name
            && !$GLOBALS['frontend_admin']
            && $_SESSION['egotec_page_preview'][$identity = $this->getIdentity()]
        ) {
            // Echte Vorschau.
            $this->field = $_SESSION['egotec_page_preview'][$identity]['field'];
            $this->extra = Ego_System::cleanTypes($_SESSION['egotec_page_preview'][$identity]['extra']) ?: [];
            $this->lastChangeDate = $this->field['m_date'];
        } else {
            // Im Adminbereich/Frontend Administration ist die aktuelle Page immer der letzte Archiveintrag
            if (
                $archive
                || (
                    $this->isPublicSave()
                    && ($GLOBALS['is_admin'] || $GLOBALS['frontend_admin'] || $_REQUEST['preview'])
                    && !empty($GLOBALS['site'])
                    && empty($GLOBALS['public_save_get_original_page'])
                    && empty($GLOBALS['auto_translate_get_original_page'])
                    && $this->_site->name == $GLOBALS['site']->name
                    && in_array($this->field['id'], array($_REQUEST['list'], $_REQUEST['id'], $_REQUEST['field']['id']))
                )
            ) {
                $db = new_db_connection();
                $db->select(array(
                    'table' => $this->_site->pageTable.'_v',
                    'where' => 'id = :id',
                    'order' => 'm_date DESC',
                    'limit' => 1,
                    'bind' => array(
                        'id' => $this->field['id']
                    )
                ));
                if ($db->nextRecord() && $db->Record['m_date'] > $this->field['m_date']) {
                    // Daten des Archivs verwenden
                    $this->field = $db->Record;
                    $this->extra = $this->field['extra']?unserialize($this->field['extra']):array();
                    $this->archiveOnly = true;
 
                    // Mediapool Archiv verwenden (nicht für Input Plugins)
                    if (empty($_REQUEST['input'])) {
                        $current_dir = $this->getMediapool()->dir().$this->getMediapool()->currentDir;
                        $this->getMediapool()->currentDir = (string) Ego_System::dateEncode($this->field['m_date']);
                        $archive_dir = $this->getMediapool()->dir().$this->getMediapool()->currentDir;
                        if (
                            !Ego_System::file_exists($archive_dir)
                            && Ego_System::file_exists($current_dir)
                        ) {
                            // Automatische Migration: Existiert kein Mediapool Archiv, dann wird current kopiert
                            Ego_System::copy($current_dir, $archive_dir);
                        }
                    }
                }
            }
 
            // Standardsprache automatisch korrigieren wenn diese nicht existiert
            if (
                $this->extra['language_standard']
                && !in_array($this->extra['language_standard'], $this->_site->getLanguages())
            ) {
                $this->extra['language_standard'] = $this->_site->language;
                $this->updateExtra($this->extra, true, true);
            }
 
            // Ist diese Page die aktuelle Seite in der Frontend Administration, dann automatisch umwandeln
            if (
                !empty($GLOBALS['frontend_admin'])
                && !empty($GLOBALS['smarty'])
                && $this->isCurrentPage(true)
            ) {
                $this->frontendAdmin();
            }
        }
        if ($this->extra['mime_type'] && !is_string($this->extra['mime_type'])) {
            $this->extra['mime_type'] = ''; // Falls in Mime-Type kein String steht.
        }
        $this->field['cache'] = (int)$this->field['cache']; // Der Cache ist ein Integer
 
        // Page Informationen laden
        $this->_loadConfig();
 
        // Individuelles Standard Layout verwenden, wenn keines definiert ist
        if (empty($this->extra['_layout'])) {
            $this->extra['_layout'] = $this->conf['default_layout'];
        }
 
        // Standard Blöcke in einer statischen Orientierung müssen immer gesetzt sein
        if (is_array($this->conf['layouts'][$this->extra['_layout']]['blocks'])) {
            foreach ($this->conf['layouts'][$this->extra['_layout']]['blocks'] as $orient => $info) {
                if (!empty($info['default']) && $info['static']) {
                    if (!is_array($this->extra['_blocks'])) {
                        $this->extra['_blocks'] = array();
                    }
                    $this->extra['_blocks'][$orient] = explode(',', $info['default']);
 
                    // Andere Blöcke sind in dieser statischen Orientierung nicht erlaubt und werden automatisch entfernt
                    $this->conf['layouts'][$this->extra['_layout']]['blocks'][$orient]['allow'] = implode(',', array_unique($this->extra['_blocks'][$orient]));
                    unset($this->conf['layouts'][$this->extra['_layout']]['blocks'][$orient]['disallow']);
                }
            }
        }
 
        if (is_array($this->extra['_blocks'])) {
            // Blöcke die nicht erlaubt sind nicht anzeigen
            if (isset($this->conf['layouts'])) {
                // Prüfen, ob dieser Block erlaubt ist.
                $validate = function ($block, $orient, $type) use (&$validate) {
                    $info = $this->conf['layouts'][$this->extra['_layout']]['blocks'][$orient];
                    if (isset($info[$type])) {
                        $result = $type == 'allow' ? false : true;
                        foreach (explode(',', $info[$type]) as $name) {
                            switch ($type) {
                                case 'allow':
                                    if ($name[0] == '@') {
                                        if ($validate($block, substr($name, 1), 'allow')) {
                                            $result = true;
                                            break 2;
                                        }
                                    } elseif ($block == $name) {
                                        $result = true;
                                        break 2;
                                    }
                                    break;
                                case 'disallow':
                                    if ($name[0] == '@') {
                                        if (!$validate($block, substr($name, 1), 'disallow')) {
                                            $result = false;
                                            break 2;
                                        }
                                    } elseif ($block == $name) {
                                        $result = false;
                                        break 2;
                                    }
                            }
                        }
                        return $result;
                    }
                    return true;
                };
 
                foreach ($this->extra['_blocks'] as $orient => $blocks) {
                    if (is_array($blocks)) {
                        foreach ($blocks as $index => $block) {
                            if (
                                !$validate($block, $orient, 'allow')
                                || !$validate($block, $orient, 'disallow')
                                || (
                                    $block == 'template' // Das Standard Template entfernen
                                    && $this->conf['template_block'] !== true // ...wenn dieses nicht erwünscht ist
                                    && $this->conf['blocks']['template']['removable'] === true // ...und explizit entfernt werden darf
                                )
                            ) {
                                if (isset($this->extra['_blocks'][$orient][$index])) {
                                    unset($this->extra['_blocks'][$orient][$index]);
                                }
                                if (isset($this->extra['_contents'][$orient][$index])) {
                                    unset($this->extra['_contents'][$orient][$index]);
                                }
                            }
                        }
                    }
                }
            }
 
            // Schlüssel aller Block Inhalte korrigieren und Standardwerte setzen
            foreach ($this->extra['_blocks'] as $orient => $blocks) {
                if (is_array($blocks)) {
                    $num = 0;
                    $contents = array();
                    foreach ($blocks as $index => $block) {
                        if (isset($this->extra['_contents'][$orient][$index])) {
                            $new_index = $index;
                            if ($new_index >= $num + 1) {
                                $new_index = $num;
                                $this->extra['_blocks'][$orient][$new_index] = $block;
                                unset($this->extra['_blocks'][$orient][$index]);
                            }
                            $contents[$new_index] = $this->extra['_contents'][$orient][$index];
                        } elseif (isset($this->conf['blocks'][$block]['default'][$orient])) {
                            $contents[$index] = $this->conf['blocks'][$block]['default'][$orient];
                        }
                        $num++;
                    }
                    $this->extra['_contents'][$orient] = $contents;
                }
            }
        }
 
        // Mediapool Konfiguration korrigieren
        if (isset($this->extra['mediapool']) && !is_array($this->extra['mediapool'])) {
            $this->extra['mediapool'] = array();
        }
 
        // Sicherstellen, dass die aus der Datenbank ermittelten Felder den richtigen Typ verwenden
        $this->field['id'] = (int) $this->field['id'];
        $this->field['name'] = (string) $this->field['name'];
        $this->field['title'] = (string) $this->field['title'];
        $this->field['url'] = (string) $this->field['url'];
        $this->field['short'] = (string) $this->field['short'];
        $this->field['content'] = (string) $this->field['content'];
        $this->field['extra'] = (string) $this->field['extra'];
        $this->field['a_date'] = (string) $this->field['a_date'];
        $this->field['c_date'] = (string) $this->field['c_date'];
        $this->field['a_user'] = (string) $this->field['a_user'];
        $this->field['c_user'] = (string) $this->field['c_user'];
        $this->field['type'] = (string) $this->field['type'];
        $this->field['children_order'] = (string) $this->field['children_order'];
        $this->field['order_field'] = (int) $this->field['order_field'];
        $this->field['nav_hide'] = (int) $this->field['nav_hide'];
        $this->field['inactive'] = (int) $this->field['inactive'];
        $this->field['cache'] = (int) $this->field['cache'];
        $this->field['release_from'] = (string) $this->field['release_from'];
        $this->field['release_until'] = (string) $this->field['release_until'];
        $this->field['workflow'] = (string) $this->field['workflow'];
        $this->field['workflow_state'] = (int) $this->field['workflow_state'];
        $this->field['deleted'] = (int) $this->field['deleted'];
    }
 
    private function _loadConfig() {
        // Konfigurationen lesen
        $cache_key = 'pageConf'.md5(serialize(array($this->field['type'], $_SERVER['REQUEST_SUFFIX'])));
        $this->conf = $this->_site->getCacheEntry($cache_key);
        if ($this->conf === null) {
            // 1. System
            $confs = array(
                $GLOBALS['egotec_conf']['lib_dir'] . 'page/conf.json'
            );
 
            $get_type_confs = function($path) use (&$confs) {
                $parts = explode('/', $this->field['type']);
                $i = 0;
                do {
                    $confs[] = str_replace('*', implode('/', array_slice($parts, 0, ++$i)), $path);
                } while ($i < sizeof($parts));
            };
 
            $get_type_confs($GLOBALS['egotec_conf']['lib_dir'] . 'type/site/*/admin/conf.json');
 
            foreach (array('', $_SERVER['REQUEST_SUFFIX']) as $suffix) {
                if (!empty($suffix) && trim(mb_strtolower(ltrim($suffix, '.'))) != 'html') {
                    $suffix = '.' . mb_strtolower(ltrim($suffix, '.'));
                }
                if ($suffix == '.html') {
                    continue;
                }
 
                // 2. Designvorlage
                if ($this->_site->theme) {
                    $confs[] = $GLOBALS['egotec_conf']['pub_dir'] . 'theme/' . $this->_site->theme . '/site/admin/conf' . $suffix . '.json';
                }
 
                // 3. Global
                if ($this->_site->globalAllowed()) {
                    $confs[] = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/conf.json';
 
                    // 4. Global / Designvorlage
                    if ($this->_site->theme) {
                        $confs[] = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/' . $this->_site->theme . $suffix . '.json';
                    }
 
                    // 5. Global / Standarddesign
                    if ($this->_site->skin) {
                        $confs[] = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/' . $this->_site->skin . $suffix . '.json';
                    }
                }
 
                // 6. Mandant
                $confs[] = $GLOBALS['egotec_conf']['site_dir'] . $this->_site->name . '/admin/conf' . $suffix . '.json';
 
                // 7. Designvorlage / Seitentyp
                if ($this->_site->theme) {
                    $get_type_confs($GLOBALS['egotec_conf']['pub_dir'] . 'theme/' . $this->_site->theme . '/site/*/admin/conf' . $suffix . '.json');
                }
 
                // 8. Global / Seitentyp
                if ($this->_site->globalAllowed()) {
                    $get_type_confs($GLOBALS['egotec_conf']['site_dir'] . '_global/*/admin/conf' . $suffix . '.json');
 
                    // 9. Global / Seitentyp / Designvorlage
                    if ($this->_site->theme) {
                        $get_type_confs($GLOBALS['egotec_conf']['site_dir'] . '_global/*/admin/' . $this->_site->theme . $suffix . '.json');
                    }
 
                    // 10. Global / Seitentyp / Standarddesign
                    if ($this->_site->skin) {
                        $get_type_confs($GLOBALS['egotec_conf']['site_dir'] . '_global/*/admin/' . $this->_site->skin . $suffix . '.json');
                    }
                }
 
                // 11. Mandant / Seitentyp
                $get_type_confs($GLOBALS['egotec_conf']['site_dir'] . $this->_site->name . '/*/admin/conf' . $suffix . '.json');
            }
 
            $this->conf = array();
            $confs = array_unique($confs);
            foreach ($confs as $file) {
                if (Ego_System::file_exists($file)) {
                    $this->conf = Ego_System::getJSON($file, $this->conf, true, ['plugins', 'toolbar', 'menubar', 'editor.options']);
                }
            }
            if (empty($this->conf['default_layout'])) {
                $this->conf['default_layout'] = 'default'; // Standard Layout ist "default", wenn keines definiert ist
            }
            unset($this->conf['site'], $this->conf['admin']); // Site Konfigurationen nicht in Page aufnehmen
            $this->_site->setCacheEntry($cache_key, $this->conf);
        }
        if ($this->conf['main_orient']) {
            // Die Haupt-Orientierung überschreiben
            $this->mainOrient = $this->conf['main_orient'];
        }
    }
 
    public function __call($function, $params) {
        // Mediapool Methoden beginnen mit "pool*"
        if (strpos($function, 'pool') === 0 && is_callable($call = [$this->getMediapool(), lcfirst(substr($function, 4))])) {
            egotec_deprecated_log('18.4', 'Please use getMediapool() and the Mediapool object\'s methods.');
            return call_user_func_array($call, $params);
        }
 
        // Page Magic Methoden
        $key = 'Page.magic'.md5(serialize(array($function, $this->field['type'])));
        $magic_file = $this->_site->getCacheEntry($key);
        if ($magic_file === null) {
            $files = array(
                "{$this->field['type']}/Page.{$function}.php"
            );
            $types = explode('/', $this->field['type']);
            while (array_pop($types)) {
                if (!empty($types)) {
                    $files[] = implode('/', $types) . "/Page.{$function}.php";
                }
            }
            $files[] = "Page.{$function}.php";
            foreach ($files as $file) {
                if ($found = $this->_site->getSiteFile($file)) {
                    $magic_file = $found;
                    $this->_site->setCacheEntry($key, $magic_file);
                    break;
                }
            }
 
            // Auch wenn keine Magic Methode gefunden wurde, das Ergebnis zwischenspeichern
            if ($magic_file === null) {
                $this->_site->setCacheEntry($key, '');
            }
        }
        if (empty($magic_file)) {
            $magic_file = $GLOBALS['egotec_conf']['lib_dir'] . 'base/Page.' . $function . '.php';
        }
        if (!file_exists($magic_file)) {
            throw new Page_Exception("Method 'Page.$function' not found", Page_Exception::METHOD_NOT_FOUND);
        }
        require_once($magic_file);
        return call_user_func($function, $this, $params);
    }
 
    public function getTableSuffix() {
        return $this->tableSuffix;
    }
 
    public function setTableSuffix($suffix = '') {
        $this->tableSuffix = $suffix;
    }
 
    function getUser($user_type='c') {
        require_once('auth/Auth.php');
        return Auth::getUserRecord($this->field[$user_type.'_user']);
    }
 
    private function _archiveEntry() {
        if (!$this->getTableSuffix()) {
            $table = $this->_site->pageTable.'_v';
            $db = new_db_connection();
 
            $field = $this->field;
            unset($field['has_children']);
 
            $field['title'] = $field['title'] ?: '';
            $field['a_user'] = $field['a_user'] ?: '';
            $field['c_user'] = $field['c_user'] ?: '';
            unset($field['parents']);
            $db->insert(array(
                'table'     => $table,
                'set'       => $field,
                'primary'   => array('id', 'm_date'),
                'replace'   => true
            ));
 
            // Mediapool archivieren
            $this->getMediapool()->archive($field['m_date']);
        }
    }
 
    private function _insertEntry($field, $lang='') {
        if (!isset($field['id']) || $field['id']<=0) {
            $field['id'] = $this->_site->nextId();
        }
        unset($field['parents']);
 
        // Alle Felder von nicht UTF8 Zeichen befreien
        foreach ($field as $key => $value) {
            if (is_string($value)) {
                if ($key == 'extra') {
                    $field[$key] = serialize(Ego_System::filterData(unserialize($value)));
                } else {
                    $field[$key] = Ego_System::filterNonUtf8($value);
                }
            }
        }
 
        // Name und Titel ohne Leerzeichen am Anfang und Ende
        foreach (array('name', 'title') as $key) {
            if (isset($field[$key])) {
                $field[$key] = trim($field[$key]);
            }
        }
 
        $db = new_db_connection();
        $db->insert(array(
            'table' => $lang?$this->_site->name.'_'.$lang:$this->_site->pageTable.$this->getTableSuffix(),
            'set'   => $field
        ));
        if ($lang) {
            $site = clone $this->_site;
            $site->setLanguage($lang);
        } else {
            $site = $this->_site;
        }
        $class = $site->getPageClass($field['type']);
        $child = new $class($site, $field);
        $child->_archiveEntry();
        if (!isset($field['inactive']) || !$field['inactive']) {
            $this->_clearCache();
        }
 
        // Neue ID, die dieses Page Objekt erzeugt hat, merken
        self::$nextIds[] = $child->field['id'];
 
        return $child;
    }
 
    private function _changeEntry($field = array(), $asis = false, $silent = false) {
        $db = new_db_connection();
        if (!$silent) {
            $field['m_user'] = $GLOBALS['auth']->getId() ? $GLOBALS['auth']->getId() : '';
            $field['m_date'] = date('Y-m-d H:i:s');
            if (!$asis) {
                $field['c_user'] = $field['m_user'];
                $field['c_date'] = $field['m_date'];
            }
        }
        unset($this->field['idx']);
        unset($field['idx']);
        if (!isset($field['id'])) {
            $field['id'] = $this->field['id'];
        }
        if (isset($field['nav_hide']) && !is_numeric($field['nav_hide'])) { // Oracle wirft einen ORA-01722, wenn kein numerischer Wert übergeben wird.
            $field['nav_hide'] = 0;
        }
 
        // nav_hide für diesen Seitentyp hat immer einen festgelegten Wert
        if (isset($field['type'])) {
            $this->field['type'] = $field['type'];
            $this->typeInfo = [];
        }
        if (($info = $this->getTypeInfo()) && isset($info['nav_hide'])) {
            $field['nav_hide'] = (int) $info['nav_hide'];
        }
 
        // Name und Titel ohne Leerzeichen am Anfang und Ende
        foreach (array('name', 'title') as $key) {
            if (isset($field[$key])) {
                $field[$key] = trim($field[$key]);
            }
        }
 
        // Der Name der Seite darf nie leer sein
        if (isset($field['name']) && $field['name'] == '') {
            $field['name'] = isset($field['title']) && $field['name'] != ''
                ? $field['name']
                : 'Neu';
        }
 
        // Freigabe ab und bis Datum für die Datenbank leer setzen
        if (isset($field['release_from']) && empty($field['release_from'])) {
            $field['release_from'] = '0000-00-00 00:00:00';
        }
        if (isset($field['release_until']) && empty($field['release_until'])) {
            $field['release_until'] = '0000-00-00 00:00:00';
        }
 
        // Die Startseite kann nicht deaktiviert werden
        if ($field['id'] == $this->_site->rootId) {
            $field['inactive'] = self::ACTIVE_FLAG;
        }
 
        // Die komplette Cache leeren, wenn ein Bild gelöscht oder wiederhergestellt wird
        $cache_complete = isset($field['deleted'])
            && $this->field['type'] == 'multimedia/image'
            && $this->field['deleted'] != $field['deleted'];
 
        // Alle Felder von nicht UTF8 und bestimmten Unicode Zeichen befreien
        $filter = function($value) use (&$filter) {
            if (is_array($value)) {
                foreach ($value as $k => $v) {
                    $value[$k] = $filter($v);
                }
                return $value;
            }
 
            if (is_string($value)) {
                if (
                    (
                        !empty($GLOBALS['egotec_conf']['editor']['filter_unicode'])
                        || !empty($this->_site->admin['editor']['filter_unicode'])
                    )
                    && $value[0] !== '{' // Nicht für JSON Strings
                ) {
                    $value = Ego_System::filterUnicode($value);
                }
                return Ego_System::filterNonUtf8($value);
            }
            return $value;
        };
        foreach ($field as $key => $value) {
            if (is_string($value)) {
                if ($key == 'extra') {
                    $field[$key] = serialize($filter(unserialize($value)));
                } else {
                    $field[$key] = $filter($value);
                }
            }
        }
 
        if (!$this->archiveOnly) {
            // Der letzte Archiveintrag ändert nie das Original
            $db->update(array(
                'table' => $this->_site->pageTable.$this->getTableSuffix(),
                'set'   => $field,
                'where' => 'id='.$this->field['id']
            ));
 
            // Beim Veröffentlichen wird das letzte Mediapool Archiv nach current kopiert
            if (
                $this->isPublicSave()
                && $this->getMediapool()->currentDir != 'current'
            ) {
                @rename($this->getMediapool()->dir().'current', $this->getMediapool()->dir().'current.backup');
                $retry = 0;
                do {
                    Ego_System::copy($this->getMediapool()->dir().$this->getMediapool()->currentDir, $this->getMediapool()->dir().'current', '', true);
                    sleep($retry++);
                } while (!Ego_System::file_exists($this->getMediapool()->dir().'current') && $retry < 3);
                if (!Ego_System::file_exists($this->getMediapool()->dir().'current')) {
                    @rename($this->getMediapool()->dir().'current.backup', $this->getMediapool()->dir().'current');
                } else {
                    Ego_Queue::add(array('Ego_System', 'deldir'), array($this->getMediapool()->dir().'current.backup'));
                }
 
                Ego_Queue::add(array($this, 'reset'), array(false));
            }
        }
        $this->_clearCache($cache_complete);
        $this->field = array_merge($this->field, $field); // Die geänderten Werte auch direkt in das aktuelle Objekt übernehmen.
        if (isset($field['extra'])) {
            $extra = unserialize($field['extra']);
            $this->extra = $extra?$extra:array();
        }
    }
 
    public function _getAncestorsIds($page, $query, $param = array()) {
        $ancestors_ids = array();
        if ($page) {
            $cache_key = '_getAncestorsIds.'
                .$page->field['id']
                .'.'
                .($query ? md5(serialize($query)) : '-')
                .($param ? md5(serialize($param)) : '-');
            $cache_val = $page->getSite()->getCacheEntry($cache_key);
            if ($cache_val) {
                return $cache_val;
            }
            foreach ($page->getParents($query, $param) as $parent) /* @var $parent Page */ {
                $ancestors_ids[] = $parent->field['id'];
                $ancestors_ids = array_merge($ancestors_ids, $this->_getAncestorsIds($parent, $query, $param));
            }
            $page->getSite()->setCacheEntry($cache_key, $ancestors_ids);
        }
        return $ancestors_ids;
    }
 
    private function _getDescendantsIds($page, $query=array(), $param=array(), &$descendants=array()) {
        $query['hash'].= ':'.$page->field['id'];
        foreach ($page->getChildren($query, $param) as $child) /* @var $child Page */ {
            if (in_array($child->field['id'], $descendants)) { // Endlosschleifen abfangen
                ; // egotec_error_log('infinite loop protection on '.$child->field['id']);
            } else {
                set_time_limit(30);
                $descendants[] = $child->field['id'];
                if ($child->field['has_children']) { // Nur weiter nach unten gehen, wenn eine Seite tatsächlich Kinder besitzt.
                    $this->_getDescendantsIds($child, $query, $param, $descendants);
                }
            }
        }
    }
 
    private function _getRights($perm_type='') {
        return new_db_connection(array(
            'fields'    => '*',
            'from'      => $this->_site->pageTable.'_rights',
            'where'     => "page_id=".$this->field['id'].($perm_type?" AND perm='".$perm_type."'":"")
        ));
    }
 
    private function _getUsers($perm_type='') {
        return new_db_connection(array(
            'fields'    => '*',
            'from'      => $this->_site->pageTable.'_users',
            'where'     => "page_id=".$this->field['id'].($perm_type?" AND perm='".$perm_type."'":'')
        ));
    }
 
    private function _getEmptyEntry($new=array()) {
        unset($new['idx']);
        unset($new['parents']);
 
        $user_id = $GLOBALS['auth']->getId() ? $GLOBALS['auth']->getId() : '';
        $date = date('Y-m-d H:i:s');
        $empty = array(
            'id'            => '',
            'title'         => 'Neue Seite',
            'name'          => 'Neu',
            'short'         => '',
            'content'       => '',
            'extra'         => '',
            'type'          => 'page',
            'cache'         => self::CACHE_BROWSER|self::CACHE_PROXY|self::CACHE_SERVER,
            'inactive'      => self::INACTIVE_FLAG,
            'release_from'  => '0000-00-00 00:00:00',
            'release_until' => '0000-00-00 00:00:00',
            'nav_hide'      => 0,
            'deleted'       => 0,
            'a_date'        => $date,
            'c_date'        => $date,
            'm_date'        => $date,
            'a_user'        => $user_id,
            'c_user'        => $user_id,
            'm_user'        => $user_id,
            'order_field'   => 0,
            'children_order'=> 'children',
            'workflow_state'=> 0,
            'workflow'      => '',
            'url'           => ''
        );
        if ($new) {
            foreach ($new as $key => $value) {
                if (!is_null($value)) {
                    $empty[$key] = $value;
                }
            }
        }
        return $empty;
    }
 
    function hasRights($rights, $user_id = false, $cache = true) {
        return $this->_site->hasRightsOnId($this->field['id'], $rights, $user_id, $cache);
    }
 
    public function hasUserRight(string $right_type, string $user_id): bool {
        $user_rights = $this->getUsersArray();
 
        if (isset($user_rights[$right_type])) {
            foreach ($user_rights[$right_type] as $user_right) {
                if ($user_right['user_id'] === $user_id) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    public function hasRightsOn($perm) {
        // Gruppen/Rollen prüfen
        $rights = $this->getRightsArray($perm);
        if (!empty($rights[$perm])) {
            foreach ($rights[$perm] as $right) {
                if ($right['group_id'] != '*' && $right['role_id'] != '*') {
                    return true;
                }
            }
        }
 
        // Benutzer prüfen
        $users = $this->getUsersArray($perm);
        if (!empty($users[$perm])) {
            foreach ($users[$perm] as $user) {
                if ($user['user_id'] != '*') {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    function newChild($field = array(), $extra = array(), $inherit=true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'newChild';
        }
 
        $original_field = !isset($field) ? ($field = array()) : $field;
        $original_extra = !isset($extra) ? ($extra = array()) : $extra;
 
        if ($field['deleted'] == 1) { // Es wird grundsätzlich keine Seite angelegt, die das deleted flag gesetzt hat.
            return false;
        }
 
        if (!$extra['release_id'] && $this->_site->admin['multi_lang']['auto_link']) { // Automatische Verknüpfung in alle Sprachen erstellen (außer für Freigabekopien).
            $extra['language_standard'] = $this->_site->language;
            foreach ($this->_site->getLanguages() as $lang) {
                $extra['language_link'][$lang] = $lang != $extra['language_standard']
                    && Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'translate')
                    && $this->extra['language_link'][$lang] == 2
                        ? 2 : 1;
            }
        } elseif(!$extra['language_standard']) {
            if ($this->extra['language_standard'] == $this->_site->language) {
                // Die Sprachverknüpfungen nur bei der Standardspreche vererben
                $extra['language_standard'] = $this->extra['language_standard'];
                $extra['language_link'] = $this->extra['language_link'];
                if (!$extra['language_standard']) {
                    $extra['language_standard'] = $this->_site->language;
                }
                if (!$extra['language_link']) {
                    $extra['language_link'] = array();
                    foreach ($this->_site->getLanguages() as $lang) {
                        if ($lang == $extra['language_standard']) {
                            $extra['language_link'][$lang] = 1;
                        } else {
                            $extra['language_link'][$lang] = 0;
                        }
                    }
                }
            } else {
                // ansonsten wird die aktuelle Sprache zur Standardsprache
                $extra['language_standard'] = $this->_site->language;
            }
        }
 
        if ($inherit) { // Eigenschaften vererben.
            // Den Workflow auf die neue Seite kopieren
            if ($this->_site->admin['workflow']['enabled'] && $this->field['workflow']) {
                $field['workflow'] = $this->field['workflow'];
                if ($this->extra['workflows']) {
                    $extra['workflows'] =  $this->extra['workflows'];
                }
            }
 
            // Intranet- und Navigationsflag vererben.
            $field['nav_hide'] = $field['nav_hide'] === 0 ? 0 : ((int) $field['nav_hide']) | ((int) $this->field['nav_hide']);
 
            // Template und Design Variante vererben (nur bei gleichen Seitentypen).
            if (
                $this->field['type'] == $field['type']
                || (!isset($field['type']) && $this->field['type'] == 'page')
            ) {
                if (!empty($this->extra['_template']) && empty($extra['_template'])) {
                    $extra['_template'] = $this->extra['_template'];
                }
                if (!empty($this->extra['_style']) && empty($extra['_style'])) {
                    $extra['_style'] = $this->extra['_style'];
                }
            }
 
            // IP Ansichtsrechte vererben
            if (empty($extra['ip_rights']) && !empty($this->extra['ip_rights'])) {
                $extra['ip_rights'] = $this->extra['ip_rights'];
            }
        }
        $field = $this->_getEmptyEntry($field);
 
        // Bereichspasswort vererben
        if ($this->extra['area_password'] && !$extra['area_password']) {
            $extra['area_password'] = $this->extra['area_password'];
        }
 
        $extra = Ego_System::cleanTypes($extra);
        $field['extra'] = serialize($extra);
 
        $new_page = $this->_insertEntry($field);
        $new_page->addParent($this->field['id']);
        $field['id'] = $new_page->field['id'];
        if (
            !$new_page->isWorkflowCopy()
            && !$new_page->isReleaseCopy()
            && !$new_page->isClone()
            && is_array($new_page->extra['language_link'])
        ) { // Automatisch Verknüpfung in alle Sprachen erstellen.
            foreach ($this->_site->getLanguages() as $lang) {
                if ($lang != $this->_site->language && $new_page->extra['language_link'][$lang]) {
                    $lang_page = $new_page->getLanguagePage($lang, array('auth_or' => '1=1', 'inactive' => true, 'only_active' => false));
                    if ($lang_page) {
                        continue;
                    }
                    $lang_parent = $this->getLanguagePage($lang, array('auth_or' => '1=1', 'deleted_or' => '1=1', 'inactive' => true, 'only_active' => false));
                    if ($lang_parent && $lang_parent->field['deleted']) {
                        $lang_parent->undelete();
                    }
 
                    // Automatisch übersetzen
                    $translated = $new_page->autoTranslate([
                        'field' => $field,
                        'extra' => $extra
                    ], $lang, false);
 
                    $lang_page = $this->_insertEntry($translated['field'], $lang);
                    $new_page->createPath($lang);
                    $lang_page->addParent($this->field['id']);
                    // Die Rechte der aktuellen Seite auf die neue Seite kopieren, das Bearbeitungsrecht aber auf 'Untermenüpunkt anlegen' setzen.
                    $new_rights = $this->getRightsArray();
                    $new_rights['edit'] = $new_rights['child'];
                    $new_users = $this->getUsersArray();
                    $new_users['edit'] = $new_users['child'];
                    $lang_page->setRightsArray($new_rights);
                    $lang_page->setUsersArray($new_users);
                }
            }
        }
 
        $this->message = $GLOBALS['auth']->translate('Neue Seite wurde erstellt!');
        if ($new_page->field['inactive']) {
            $this->message.= "\n".$GLOBALS['auth']->translate('Diese Seite ist inaktiv (nicht online verfügbar).');
        } else {
            $this->message.= "\n".$GLOBALS['auth']->translate('Diese Seite ist freigeschaltet.');
        }
 
        // Die Rechte der aktuellen Seite auf die neue Seite kopieren, das Bearbeitungsrecht aber auf 'Untermenüpunkt anlegen' setzen.
        $new_rights = $this->getRightsArray();
        $new_rights['edit'] = $new_rights['child'];
        $new_users = $this->getUsersArray();
        $new_users['edit'] = $new_users['child'];
        $new_page->setRightsArray($new_rights);
        $new_page->setUsersArray($new_users);
 
        // Rechte klonen
        $new_page->_updateCloneRights();
 
        $new_page->updateIndex();
        $new_page->hookUpdate('newchild');
        $new_page->hookUpdate();
 
        $this->replicate('newChild', $original_field, $original_extra, $inherit);
 
        if ($new_page->_site->admin['video']['convert'] && preg_match('/video/', $new_page->extra['mime_type']) && $new_page->extra['mime_type'] != 'video/mp4') {
            // Video konvertieren
            Ego_Queue::add(array($new_page, 'convertVideo'));
        } elseif($new_page->_site->admin['video']['compress'] && $new_page->extra['mime_type'] == 'video/mp4') {
            // Video komprimieren
            Ego_Queue::add([$new_page, 'compressVideo']);
        }
 
        return $new_page;
    }
 
    public function hasFile($name, $suffix = '') {
        $children = $this->getChildren(array(
            'where' => "name = :name AND type IN ('multimedia/file', 'multimedia/image')",
            'bind' => array(
                'name' => $name
            )
        ), array(
            'inactive' => 1,
            'only_active' => false
        ));
        if ($page = $children->nextPage()) {
            if (!$suffix || $page->extra['image_type'] == $suffix) {
                return $page;
            }
        }
        return null;
    }
 
    public function newFile($source, $name, $options = array(), $suffix = '') {
        if ($this->_site->site['type'] == 'media' && $this->validateFile($source, $name)) {
            @set_time_limit(0);
 
            // WebDAV benötigt immer ein globales Site Objekt
            if (!isset($GLOBALS['site'])) {
                $GLOBALS['site'] = $this->getSite();
            }
 
            require_once 'media/functions.php';
            require_once 'base/Ego_MimeType.php';
 
            if ($name) {
                $path_info = Ego_System::pathinfo($name);
 
                if (!$path_info['extension'] && $suffix) {
                    $path_info['extension'] = $suffix;
                }
 
                $GLOBALS['mediaType'] = $path_info['extension'];
            }
 
            $mime = new Ego_MimeType();
            $mime_type = $mime->autoDetect($source);
 
            $is_image = !(strpos($mime_type, 'image') === false);
            $field = $options;
            $extra = [];
 
            if ($field['extra']) {
                $extra = $field['extra'];
                unset($field['extra']);
            }
 
            $field['name'] = trim(Ego_System::filterNonUtf8(Ego_System::stringEncode($options['name'] ?: $name)));
            $field['title'] = trim(Ego_System::filterNonUtf8(Ego_System::stringEncode($options['title'] ?: $field['name'])));
 
            if (!Ego_System::file_exists($GLOBALS['egotec_conf']['tmp_dir'])) {
                Ego_System::mkdir($GLOBALS['egotec_conf']['tmp_dir']);
            }
 
            if (!empty($options['extra']['mime_type'])) {
                $extra['mime_type'] = $options['extra']['mime_type'];
            } else {
                $extra['mime_type'] = $mime_type;
            }
 
            if ($suffix) {
                $extra['image_type'] = $suffix;
            } else {
                // Falls keine Endung angegeben ist, wird diese aus dem Namen gewonnen.
                if ($path_info['extension']) {
                    $extra['image_type'] = $path_info['extension'];
                } else {
                    // Als allerletztes die Endung aus dem Mime/Type bestimmen.
                    if (!$GLOBALS['mime2ext']) {
                        $GLOBALS['mime2ext'] = array_flip(Ego_System::getMimeTypes());
                    }
 
                    if ($extra['mime_type'] == 'image/svg') {
                        $extra['mime_type'] = 'image/svg+xml';
                    }
 
                    $extra['image_type'] = $GLOBALS['mime2ext'][$extra['mime_type']];
                }
            }
 
            $extra['origFileSize'] = Ego_System::filesize($source);
 
            if ($is_image && $extra['origFileSize'] > 0) {
                require_once 'base/Ego_Image.php';
 
                $imageTransform = new Ego_Image();
                $imageTransform->load($source);
 
                if (!minimumImageDimensions($imageTransform, $this->_site)) {
                    return null;
                }
 
                scaleImageOnUpload($imageTransform, $this->_site);
 
                $extra['origImgWidth'] = $imageTransform->getImageWidth();
                $extra['origImgHeight'] = $imageTransform->getImageHeight();
 
                $keywords = [];
                setExifData($field, $extra, $keywords, $imageTransform, $this);
            } else {
                getFileInfo($source, $extra);
            }
 
            $field['type'] = 'multimedia/' . ($is_image ? 'image' : 'file');
            $field['inactive'] = self::ACTIVE_FLAG;
            $field['parents'] = ','.trim($this->field['id'],',').',';
 
            // Wenn Search+ aktiviert ist, wird der Dateiinhalt in die DB aufgenommen
            if (!$is_image && $GLOBALS['egotec_conf']['openoffice']['active']) {
                require_once 'openoffice/converter.php';
                $field['content'] = convert_content($source, $extra['image_type'], $extra['mime_type']);
            }
 
            $child = $this->newChild($field, $extra);
 
            if (isset($keywords) && !empty($keywords)) {
                foreach ($keywords as $keyword) {
                    $child->addParent($keyword);
                }
            }
 
            // Datei nach var/media/ kopieren
            $media_dir = $GLOBALS['egotec_conf']['var_dir'].'media'.DIRECTORY_SEPARATOR.$this->_site->name;
            if (!Ego_System::file_exists($media_dir)) {
                Ego_System::mkdir(strtr($media_dir, '/', DIRECTORY_SEPARATOR), 0777);
            }
 
            $dest = $media_dir.DIRECTORY_SEPARATOR.$child->getMediaFilename(true);
            Ego_System::copy(
                $source,
                $dest
            );
 
            // Archiveintrag
            Ego_System::copy(
                $dest,
                $media_dir.DIRECTORY_SEPARATOR.$child->getMediaFilename(
                    true,
                    '_'.strtotime($child->field['m_date'])
                ),
                '',
                true
            );
 
            // Bilder umwandeln
            Ego_Queue::add([$child, 'convertImages']);
 
            return $child;
        }
 
        return null;
    }
 
    public function extractFile($source, &$images = array()) {
        $id = $this->field['id'];
        $dir = $GLOBALS['egotec_conf']['tmp_dir'].'import/zip/';
        $name = time();
        $dest = $dir.$name;
        if (!Ego_System::file_exists($dest)) {
            Ego_System::mkdir(strtr($dest, '/', DIRECTORY_SEPARATOR), 0777, true);
        }
        $file = tempnam($dir, 'ZIP_').'.zip';
        if (@move_uploaded_file($source, $file)) {
            require_once('media/functions.php');
            require_once('Archive/Zip.php');
            $zip = new Archive_Zip($file);
            chdir($dest);
            @set_time_limit(0);
            $zip->extract();
            chdir($GLOBALS['egotec_conf']['bin_dir'].'admin');
            $num = GetDir($dest, '', $this->field['id'], true, $images);
            Ego_System::deldir($dest, true);
            @unlink($file);
            if (isset($GLOBALS['_GetDir_firstId'])) {
                $id = $GLOBALS['_GetDir_firstId'];
                unset($GLOBALS['_GetDir_firstId']);
            }
        }
        return $this->_site->getPage($id);
    }
 
    public function updateFile($source, $name = '') {
        if (!$this->validateFile($source, $name)) {
            return false;
        }
 
        // WebDAV benötigt immer ein globales Site Objekt
        if (!isset($GLOBALS['site'])) {
            $GLOBALS['site'] = $this->getSite();
        }
 
        require_once('media/functions.php');
        require_once('base/Ego_MimeType.php');
        if ($name) {
            $path_info = Ego_System::pathinfo($name);
            $GLOBALS['mediaType'] = $path_info['extension'];
        }
        $mime = new Ego_MimeType();
        $mime_type = $mime->autoDetect($source);
        $is_image = !(strpos($mime_type, 'image') === false);
 
        $field = array();
        $extra = $this->extra;
 
        $extra['mime_type'] = $mime_type;
        if ($name) {
            if ($path_info['extension']) {
                $extra['image_type'] = $path_info['extension'];
            }
        }
        if (!$name || !$extra['image_type']) {
            // Als allerletztes die Endung aus dem Mime/Type bestimmen.
            if (!$GLOBALS['mime2ext']) {
                $GLOBALS['mime2ext'] = array_flip(Ego_System::getMimeTypes());
            }
            $extra['image_type'] = $GLOBALS['mime2ext'][$extra['mime_type']];
        }
 
        $extra['origFileSize'] = Ego_System::filesize($source);
        $field['type'] = 'multimedia/'.($is_image ? 'image' : 'file');
 
        if ($is_image) {
            require_once('base/Ego_Image.php');
            $imageTransform = new Ego_Image();
            $imageTransform->load($source);
 
            if (!minimumImageDimensions($imageTransform, $this->_site)) {
                return false;
            }
 
            // Umgewandelte Bilder löschen
            Ego_Queue::add([$this, 'clearConvertedImages']);
 
            scaleImageOnUpload($imageTransform);
 
            $extra['origImgWidth'] = $imageTransform->getImageWidth();
            $extra['origImgHeight'] = $imageTransform->getImageHeight();
 
            $keywords = [];
            setExifData($field, $extra, $keywords, $imageTransform, $this);
 
            $oldKeywords = array_reduce(
                iterator_to_array($this->getParents(['where' => "type = '_keywords/entry'"])),
                function($carry, $item) {
                    return array_merge($carry, [$item->field['id']]);
                },
                []
            );
 
            // Alte Schlagwörter entfernen
            foreach ($oldKeywords as $oldKeyword) {
                $this->unlinkFrom($oldKeyword);
            }
 
            // Neue Schlagwörter setzen
            if (isset($keywords) && !empty($keywords)) {
                foreach ($keywords as $keyword) {
                    $this->addParent($keyword);
                }
            }
        } else {
            getFileInfo($source, $extra);
        }
 
        // Wenn Search+ aktiviert ist, wird der Dateiinhalt in die DB aufgenommen
        if (!$is_image) {
            if ($GLOBALS['egotec_conf']['openoffice']['active']) {
                // OpenOffice: Inhalt neu ermitteln
                require_once('openoffice/converter.php');
                $field['content'] = convert_content($source, $extra['image_type'], $extra['mime_type']);
            } elseif (Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'elastic')) {
                // Elasticsearch: Inhalt leeren; wird beim Update automatisch indiziert
                $field['content'] = '';
                unset($extra['_indexed']);
            }
        }
 
        $this->update(array(
            'field' => $field,
            'extra' => $extra
        ));
 
        // Alle Ausschnitte ebenfalls aktualiseren
        if ($this->field['type'] == 'multimedia/image') {
            foreach ($this->getChildren(array(), array(
                'auth_or' => '1=1'
            )) as $child) {
                if ($child->extra['crop_image']) {
                    $extra = array(
                        'edit' => $child->extra['edit'],
                        'crop_image' => true
                    );
                    $child->updateExtra(array_merge($this->extra, $extra));
                }
            }
        }
 
        // Datei nach var/media/ kopieren
        $media_dir = $GLOBALS['egotec_conf']['var_dir'].'media'.DIRECTORY_SEPARATOR.$this->_site->name;
        if (!Ego_System::file_exists($media_dir)) {
            Ego_System::mkdir(strtr($media_dir, '/', DIRECTORY_SEPARATOR), 0777, true);
        }
 
        // Falls die Datei der Standard Sprache noch nicht im Sprach Verzeichnis liegt, dann verschieben
        if (
            $this->_site->language == $this->_site->site['default_language']
            && !Ego_System::file_exists($media_dir.DIRECTORY_SEPARATOR.$this->getMediaFilename(true))
            && Ego_System::file_exists($media_dir.DIRECTORY_SEPARATOR.$this->field['id'])
        ) {
            rename(
                $media_dir.DIRECTORY_SEPARATOR.$this->field['id'],
                $media_dir.DIRECTORY_SEPARATOR.$this->getMediaFilename(true)
            );
 
            $mediafiles = glob($media_dir.DIRECTORY_SEPARATOR.$this->field['id'].'_*');
            if (is_array($mediafiles)) {
                foreach ($mediafiles as $mediafile) {
                    preg_match('/\d+_\d+$/', $mediafile, $name);
                    rename(
                        $mediafile,
                        $media_dir.DIRECTORY_SEPARATOR.$this->_site->language.DIRECTORY_SEPARATOR.$name[0]
                    );
                }
            }
        }
 
        // Vor dem Ersetzen das Original löschen, damit sich die Archive nicht ändern, weil diese Hardlinks sind
        $dest = $media_dir.DIRECTORY_SEPARATOR.$this->getMediaFilename(true);
        @unlink($dest);
        Ego_System::copy($source, $dest);
 
        // Archiveintrag
        Ego_System::copy(
            $dest,
            $media_dir.DIRECTORY_SEPARATOR.$this->getMediaFilename(
                true,
                '_'.strtotime($this->field['m_date'])
            ),
            '',
            true
        );
 
        Ego_System::deldir(
            $GLOBALS['egotec_conf']['cachemedia_dir'].$this->_site->name.DIRECTORY_SEPARATOR.
            $this->getMediaFilename(true)
        );
 
        if ($this->_site->admin['video']['convert'] && preg_match('/video/', $this->extra['mime_type']) && $this->extra['mime_type'] != 'video/mp4') {
            // Video konvertieren
            Ego_Queue::add(array($this, 'convertVideo'));
        } elseif($this->_site->admin['video']['compress'] && $this->extra['mime_type'] == 'video/mp4') {
            // Video komprimieren
            Ego_Queue::add([$this, 'compressVideo']);
        }
 
        return true;
    }
 
    public function updateDocumentFiles($remove = false) {
        if ($this->_site->site['type'] == 'media') {
            // Multimedia
            if ($this->field['type'] == 'multimedia/file') {
                $file = $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $this->_site->name . '/'  . $this->getMediaFilename();
                if (Ego_System::file_exists($tmp_file = $GLOBALS['egotec_conf']['tmp_dir'] . 'document-' . md5($file))) {
                    if (!$remove) {
                        $this->updateFile($tmp_file, $this->field['name'] . '.' . $this->extra['image_type']);
                    }
                    @unlink($tmp_file);
                }
            }
        } elseif (!empty($this->_site->admin['mediapool']['active'])) {
            // Mediapool
            $mediapool = $this->getMediapool();
            foreach ($mediapool->getDirs() as $dir) {
                foreach ($mediapool->list($dir, ['only_files' => true]) as $item) {
                    if (Ego_System::file_exists($tmp_file = $GLOBALS['egotec_conf']['tmp_dir'] . 'document-' . md5($item['file']))) {
                        if (!$remove) {
                            $mediapool->put($tmp_file, $item['name'], $dir);
                        }
                        @unlink($tmp_file);
                    }
                }
            }
        }
    }
 
    function copyTo($id, $recursive = false, $params = array(), &$copied_pages = array())
    {
        $original_copied_pages = $copied_pages;
 
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'copyTo';
        }
 
        if ($this->isClone() || $this->isWorkflowCopy() || $this->isReleaseCopy()) {
            return false; // Keine Klone, Workflow- und Freigabekopien kopieren
        }
 
        $param = array(
            'auth_or' => '1=1',
            'only_active' => false,
            'inactive' => true
        );
 
        /* @var $new_parent Page */
        if (is_a($id, 'Page')) {
            // $id ist bereits das Page Objekt
            $new_parent = $id;
        } elseif (is_a($params['site'], 'Site')) {
            // Übergebenes Site Objekt
            $new_parent = $params['site']->getPage($id, $param);
        } elseif (
            $this->_site->name == $GLOBALS['site']->name
            && $this->_site->language == $GLOBALS['site']->language
        ) {
            // Quell- und Ziel-Mandant sind identisch
            $new_parent = $this->_site->getPage($id, $param);
        } else {
            // Kopieren über Mandanten hinweg
            if ($this->_site->site['type'] == 'media') {
                $new_parent = $GLOBALS['site']->getMediaSite()->getPage($id, $param);
            } else {
                $new_parent = $GLOBALS['site']->getPage($id, $param);
            }
        }
        $site_parent = $new_parent->getSite();
 
        // Kopieren in den selben Mandanten: Endlosschleife vermeiden
        if ($this->_site->name == $site_parent->name) {
            $ancestors = $this->_getAncestorsIds(
                $new_parent,
                array('fields' => 'id'),
                array('auth_or' => '1=1')
            );
            if (in_array($this->field['id'], $ancestors)) {
                return false;
            }
        }
 
        // Kopierte Werte setzen
        if (is_array($params['field'])) {
            $field = $params['field'];
        } else {
            $field = $this->field;
        }
        if (is_array($params['extra'])) {
            $extra = $params['extra'];
        } else {
            $extra = $this->extra;
        }
 
        unset($field['id']);
        unset($field['extra']);
        $field['a_user'] = $GLOBALS['auth']->user->field['user_id'];
        $field['a_date'] = date('Y-m-d H:i:s');
        unset($extra['workflow_page']);
 
        // Eine kopierte Seite hat keine Klone
        unset($extra['clones']);
        foreach (array_keys($extra) as $key) {
            if (
                strpos($key, 'clone_children_') === 0
                || strpos($key, 'clone_rights_') === 0
                || strpos($key, 'clone_release_') === 0
            ) {
                unset($extra[$key]);
            }
        }
 
        // Meta Url löschen wenn die Seite im gleichen Mandanten kopiert wird
        if($this->_site->name == $site_parent->name) {
            unset($field['url']);
        }
 
        // Kopierte Seite aufräumen
        if ($params['cleanup']) {
            // Immer inaktiv
            $field['inactive'] = 1;
 
            // Keine Workflowhistorie
            unset($extra['history']);
        }
 
        // Vor dem Kopieren einer Seite dessen Felder manipulieren
        try {
            [$field, $extra] = $this->copyToFields($field, $extra);
        } catch (Exception $e) {
            // "copyToFields" existiert nicht, ignorieren
        }
 
        $copy = $new_parent->newChild($field, $extra); /* @var $copy Page */
 
        /* Evtl. vorhandene MM-Datei kopieren */
        if (file_exists($GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$this->getMediaFilename())) {
            if ($this->_site->name == $site_parent->name && $this->_site->language == $site_parent->language) {// Quell- und Ziel-Mandant sind identisch
                Ego_System::copy(
                    $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$this->getMediaFilename(),
                    $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$copy->getMediaFilename(true),
                    '',
                    true
                );
            } else { //Kopieren über Mandanten hinweg
                Ego_System::copy(
                    $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$this->getMediaFilename(),
                    $GLOBALS['egotec_conf']['var_dir'].'media/'.$site_parent->name.'/'.$copy->getMediaFilename(true),
                    '',
                    true
                );
            }
        }
 
        // Mediapool kopieren
        $this->getMediapool()->copy($copy, '', false, false, false);
 
        // Sprachen beachten
        if (
            !$copy->isReleaseCopy() // Freigabekopien werden nur in der aktuellen Sprache angelegt
        ) {
            foreach($this->_site->getLanguages() as $lang) {
                if ($lang != $this->_site->language) {
                    if (in_array($lang, $this->_site->getLanguages()) &&
                        in_array($lang, $copy->getSite()->getLanguages())
                    ) {
                        $lang_page = $this->getLanguagePage($lang); // die sprachversion der zu kopierenden seite
 
                        if ($lang_page) {
                            $lang_page_field = $lang_page->field;
                            $lang_page_extra = $lang_page->extra;
                            $lang_page_field['id'] = $copy->field['id'];
 
                            // Vor dem Kopieren einer Seite dessen Felder manipulieren
                            try {
                                [$lang_page_field, $lang_page_extra] = $this->copyToFields($lang_page_field, $lang_page_extra);
                            } catch (Exception $e) {
                                // "copyToFields" existiert nicht, ignorieren
                            }
 
                            $_param = array('auth_or'=>'1=1', 'deleted_or'=>'1=1', 'inactive'=>true);
                            $lang_copy = $copy->getLanguagePage($lang, $_param);
                            if (!$lang_copy) {
                                $copy_parent = $new_parent->getLanguagePage($lang, $_param);
                                if (!$copy_parent) { // Sprachversion der Elternseite existiert nicht, also direkt unter der Startseite einfügen
                                    $copy_parent = $copy->getSite()->getRoot()->getLanguagePage($lang, $_param);
                                }
                                $lang_copy = $copy_parent->newChild($lang_page_field, $lang_page_extra);
                            } else {    // Sprachversion existiert bereits
                                $lang_copy->update(
                                    array(
                                        'field' => $lang_page_field,
                                        'extra' => $lang_page_extra
                                    )
                                );
                            }
 
                            if($lang_copy) {
                                // Rechte übernehmen
                                $rights = array(
                                    "rights" => $lang_page->getRightsArray()
                                    ,"users" => $lang_page->getUsersArray()
                                );
                                $lang_copy->updateRights($rights, false);
                            }
                        }
                    }
                }
            }
        }
 
        if ($recursive) {
            // Bei einer Rekursion werden Mehrfacheinhängungen beibhalten
            if (!isset($copied_pages[$this->field['id']])) {
                $copied_pages[$this->field['id']] = $copy;
            }
 
            if ($params['children_param']['sitemap'] !== false) {
                $params['children_param']['sitemap'] = true;
            }
 
            $children = $this->getChildren($params['children_query'], $params['children_param']);
 
            foreach ($children as $child) {
                set_time_limit(0); // Ein Timeout verhindern.
                if ($new_child = $copied_pages[$child->field['id']]) {
                    // Mehrfacheinhängung beibehalten
                    $new_child->addParent($copy->field['id'], true);
                } else {
                    $child->copyTo($copy,$recursive,$params,$copied_pages);
                }
            }
        }
 
        if ($new_parent->extra['clones']) { // Prüfen ob die neue Elternseite Klone hat und diese dann aktualisieren
            $param = array(
                'field' => $new_parent->field
            );
            $new_parent->_updateClones($param);
        }
 
        $this->replicate('copyTo', $id, $recursive, $params, $original_copied_pages);
 
        return $copy;
    }
 
    function move($from, $to) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'move';
        }
 
        if ($from != $to && $this->addParent($to)) {
            $this->delParent($from, true);
        }
        $this->hookUpdate();
 
        $this->replicate('move', $from, $to);
    }
 
    function linkTo($id) {
        $this->addParent($id);
    }
 
    function delete($parent = false, $nostart = false, $keeplinks = true, $query = array()) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'delete';
        }
 
        if ($this->isRoot()) {
            throw new Page_Exception("Can't delete root page.", Page_Exception::ROOT_PROTECTION);
        }
 
        // Wird ein Schlagwort gelöscht, werden auch nur Schlagwörter berücksichtigt
        // TODO mit param[sitemap] = false lösen
        if ($this->field['type'] == '_keywords/entry') {
            if ($query['where']) {
                $query['where'] = "({$query['where']}) AND type = '_keywords/entry'";
            } else {
                $query['where'] = "type = '_keywords/entry'";
            }
        }
 
        $this->archiveOnly = false;
        $children = $this->getChildren(
            $query,
            array(
                'inactive' => true,
                'auth_or' => '1=1'
            )
        );
        foreach ($children as $child) { // Die Seite hat Unterseiten
            $child->delete($keeplinks ? $this : false, false, $keeplinks, $query);
            if (isset($child->extra['main_category']) && $child->extra['main_category'] == $this->field['id']) {
                unset($child->extra['main_category']);
                $child->update([], true, true);
            }
        }
 
        // Sprachverknüpfungen: wenn die Standardsprache gelöscht wird ...
        if (
            is_array($this->extra['language_link'])
            && $this->extra['language_standard'] == $this->_site->language
        ) {
            $languages = $this->_site->getLanguages();
 
            // wird ein neuer Standard gesetzt
            $standard = $languages[0] == $this->_site->language
                ? $languages[1]
                : $languages[0];
 
            // werden alle anderen sprachen durchgegangen
            foreach ($languages as $lang) {
                if ($lang == $this->_site->language) {
                    continue;
                }
 
                // Ursprüngliche Sprachverknüpfung aufheben
                $this->extra['language_link'][$lang] = 0;
 
                if (
                    ($lang_page = $this->getLanguagePage($lang, ['deleted' => -1]))
                    && is_array($lang_page->extra['language_link'])
                    && $lang_page->extra['language_link'][$this->_site->language]
                ) {
                    // und die Sprachverknüpfung gelöscht
                    $extra = $lang_page->extra;
                    $extra['language_link'][$this->_site->language] = 0;
                    $extra['language_link'][$standard] = 1;
                    $extra['language_standard'] = $standard;
 
                    $lang_page->update(array('extra' => $extra));
                }
            }
 
            // Die Sprachmatrix der gelöschten Seite wird zur Sprachmatrix der neuen Standardsprache
            $lang_page = $this->getLanguagePage($standard, ['deleted' => -1]);
            $this->extra['language_link'] = $lang_page->extra['language_link'];
            $this->extra['language_standard'] = $lang_page->extra['language_standard'];
        }
 
        $parents = $this->getParents(
            array(
                'fields' => 'id',
                'where' => "type != '_keywords/entry'"
            ),
            array(
                'sitemap' => true,
                'inactive' => true,
                'auth_or' => '1=1'
            )
        );
        if ($parent && $parents->numRecords() > 1)
        {// Die Seite ist mehrfach eingehängt
            $this->unlinkFrom($parent->field['id']);
        } else {
            if(!$nostart) {
                // Alle Workflow-, Freigabekopien zerstören
                $destroy_ids = array();
                if (!empty($this->extra['workflow_page'])) {
                    $destroy_ids[] = $this->extra['workflow_page'];
                }
                if (!empty($this->extra['release_ids'])) {
                    $destroy_ids = array_merge($destroy_ids, $this->extra['release_ids']);
                }
                foreach ($destroy_ids as $destroy_id) {
                    if ($destroy_page = $this->_site->getPage($destroy_id, array(
                        'only_active' => false,
                        'inactive' => 1,
                        'auth_or' => '1=1'
                    ))) {
                        $destroy_page->destroy(true);
                    }
                }
 
                // Sich selbst löschen
                $field['deleted'] = 1;
                $extra = $this->extra;
                unset($extra['workflow_page'], $extra['release_ids']);
                $this->update(array('field' => $field, 'extra' => $extra));
            }
        }
 
        // Achtung: wenn ich eine Klon Seite bin, dann muss die Verknüpfung aus der Originalseite entfernt werden
        if ($this->isClone()) {
            $org = $this->getCloneOriginal();
            $del_clone = $this->getParents(array(), array(
                'inactive' => true,
                'auth_or' => '1=1'
            ))->nextPage();
            $del_id = $del_clone->field['id']; // abwärtskompatibel
            if ($org) {
                $del_url = $this->getCloneUrl();
 
                $clones = array_filter(array_unique(explode(',', $org->extra['clones'])));
                $new_clones = array();
                foreach ($clones as $clone_url) {
                    if (!in_array($clone_url, array($del_id, $del_url))) {
                        $new_clones[] = $clone_url;
                    }
                }
 
                $org->extra['clones'] = implode(',', $new_clones);
                $org->updateExtra($org->extra);
            }
        }
 
        // Achtung: wenn ich eine Freigabekopie bin, dann muss die Verknüpfung aus der Originalseite entfernt werden
        if ($this->isReleaseCopy()) {
            if (
                ($org = $this->_site->getPage($this->extra['release_id'], array(
                    'only_active' => false,
                    'inactive' => 1,
                    'auth_or' => '1=1'
                )))
                && is_array($org->extra['release_ids'])
            ) {
                $org->extra['release_ids'] = array_values(array_diff($org->extra['release_ids'], array($this->field['id'])));
                $org->update(array(), true, true);
            }
        }
 
        // Schlagwort Parents durchgehen und löschen wenn:
        // -> der Mandant die Checkbox "Neues Schlagwortregister verwenden" gesetzt hat
        // -> der verwendete Schlagwortregister nicht der Mandant des Klon Originals ist
        // -> das Schlagwort ein Klon ist
        // -> das Schlagwort ansonsten nicht mehr verwendet wird
        // oder das Schlagwort Klone hat und
        // -> der verwendete Schlagwortregister des Mandanten in dem sich der Klon befindert nicht der Mandant des Originals ist
        // -> das Schlagwort ansonsten nicht mehr verwendet wird
        // Schlagwort Parents holen wenn der Mandant die Checkbox "Neues Schlagwortregister verwenden" gesetzt hat
        if ($this->getSite()->admin['keyword_register_own_site']) {
            $keyword_parents = $this->getParents(['where' => "type = '_keywords/entry'"]);
 
            if ($keyword_parents->numRecords() > 0) {
                foreach ($keyword_parents as $keyword_parent) {
                    if ($keyword_parent->isClone() && !$keyword_parent->hasChildren()
                        && $keyword_parent->getCloneOriginal()->getSite()->name != $this->getSite()->admin['keywords']['site']) {
                        $this->_deleteCloneKeywords($this, $keyword_parent);
                    } elseif (!$keyword_parent->isClone() && $keyword_parent->extra['clones']) {
                        $keyword_clones = $keyword_parent->getClones();
                        foreach ($keyword_clones as $keyword_clone) {
                            if ($keyword_clone->getSite()->name != $keyword_parent->getSite()->admin['keywords']['site']
                                && !$keyword_clone->hasChildren()) {
                                $this->_deleteCloneKeywords($keyword_parent, $keyword_clone);
                            }
                        }
                    }
                }
            }
        }
 
        $this->replicate('delete', $parent, $nostart, $keeplinks, $query);
    }
 
    protected function _destroyEntry($recursive=true) {
        @set_time_limit(0); //Wird zwingend benötigt, für den Fall dass viele Unterseiten existieren
        $db = new_db_connection();
 
        $this->message = 'Diese Seite wurde vernichtet.';
 
        if($recursive) {
            $query = array();
 
            // Wird ein Schlagwort zerstört, werden auch nur Schlagwörter berücksichtigt
            // TODO mit param[sitemap] = false lösen
            if ($this->field['type'] == '_keywords/entry') {
                $query['where'] = "type = '_keywords/entry'";
            }
 
            $pages = $this->getChildren($query, array('deleted' => 1));
            $del_array = array();
            foreach($pages as $page) { // Zunächst alle Seiten holen,
                $del_array[] = $page;
            }
            foreach($del_array as $page) { // weil es bei ms sql sonst hier zu einer Blockade kommt.
                $page->destroy(false, $recursive);
                $this->message = 'Diese Seite wurde inklusive Unterseiten erfolgreich vernichtet.';
            }
        }
 
        $parents = $this->getParents(array(), array('deleted' => -1));
        foreach ($parents as $parent) {
            $this->unlinkFrom($parent->field['id']);
        }
 
        $db->begin();
        $db->delete(array( // Aus der Tabelle löschen.
            'table' => $this->_site->pageTable,
            'where' => "id=".$this->field['id']
        ));
        $db->delete(array( // Aus dem Archiv löschen.
            'table' => $this->_site->pageTable.'_v',
            'where' => "id=".$this->field['id']
        ));
        $db->delete(array( // Aus der Rechte-Tabelle löschen.
            'table' => $this->_site->pageTable.'_rights',
            'where' => "page_id=".$this->field['id']
        ));
        $db->delete(array( // Aus der User-Tabelle löschen.
            'table' => $this->_site->pageTable.'_users',
            'where' => "page_id=".$this->field['id']
        ));
        $db->delete(array( // Aus der Kinder-Tabelle löschen.
            'table' => $this->_site->pageTable.'_children',
            'where' => 'page_id='.$this->field['id'].' OR child='.$this->field['id']
        ));
        // Aus der Extra-Tabelle löschen.
        if ($db->tableExists($this->_site->pageTable.'_extra'))
        {
            $db->delete(array(
                'table' => $this->_site->pageTable.'_extra',
                'where' => 'page_id='.$this->field['id']
            ));
        }
        $db->commit();
 
        // Evtl. vorhandene Media Dateien löschen
        $this->destroyFile();
 
        // Evtl. vorhandenen Mediapool löschen
        $this->getMediapool()->clear('', [], false);
 
        // Alle URLs löschen
        $this->removeUrls();
 
        // Suchindex aufräumen
        require_once('base/Ego_Search_Factory.php');
        $search = Ego_Search_Factory::start($this->_site->pageTable);
        try {
            $search->delete($this->field['id']);
        } catch (Exception $e) {
            // ignorieren -> id wurde im Index nicht gefunden
        }
 
        $this->message .= ' Eine Wiederherstellung ist nicht möglich.';
    }
 
    public function destroy($force=false, $recursive=true, $destroy_links=true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'destroy';
        }
 
        if ($this->isRoot()) {
            throw new Page_Exception("Can't destroy root page.", Page_Exception::ROOT_PROTECTION);
        }
        $this->archiveOnly = false;
        if (count(Ego_System::getCluster())>0) {
            $time = array();
            foreach (Ego_System::getCluster() as $cluster) {
                $log_filename = $GLOBALS['egotec_conf']['log_dir'].$GLOBALS['site']->name.'/live.'.$this->_site->name.'_'.$this->_site->language.'.'.$cluster['id'].'.up.date';
                if (file_exists($log_filename)) {
                    $time[] = file_get_contents($log_filename);
                }
            }
 
            sort($time);
 
            if (count($time) > 0) {
                $live_date = $time[0];
            } else {
                $live_date = date('Y-m-d H:i:s', time());
            }
 
        } else {
            $live_date_file = $GLOBALS['egotec_conf']['log_dir'].$this->_site->name.'/'.'live.'.$this->_site->name.'_'.$this->_site->language.'.date';
 
            if(file_exists($live_date_file)) {
                $live_date = file_get_contents($live_date_file);
            } else {
                $live_date = date('Y-m-d H:i:s', time());
            }
        }
        if (
            !$force
            && (
                ($GLOBALS['egotec_conf']['liveserver'] && !$this->getSite()->admin['live']['live_only'])
                || $this->field['m_date'] > $live_date
                || !$this->field['deleted']
            )
        ) {
            return $this->delete();
        }
 
        if (
            $destroy_links
            && is_array($this->extra['language_link'])
            && $this->extra['language_standard'] == $this->_site->language
        ) {
            foreach($this->_site->getLanguages() as $lang) {
                $flag = !empty($this->extra['language_link'][$lang]);
                if ($flag && $lang != $this->_site->language) {
                    try {
                        if ($lang_page = $this->getLanguagePage($lang, array('deleted' => -1, 'auth_or' => '1=1'))) {
                            $lang_page->_destroyEntry($recursive);
                        }
                    } catch (Site_Exception $e) {
                        // Eine nicht mehr vorhandene Sprache ignorieren
                    }
                }
            }
        }
 
        // Umgewandelte Bilder löschen
        Ego_Queue::add([$this, 'clearConvertedImages']);
 
        $this->replicate('destroy', $force, $recursive);
 
        $this->_destroyEntry($recursive);
    }
 
    function undelete($recursive = false, $query = array()) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'undelete';
        }
 
        $this->restore();
        $this->message = 'Diese Seite wurde erfolgreich wiederhergestellt.';
 
        if (
            ($this->extra['language_standard']==$this->_site->language
                || $this->_site->admin['multi_lang']['auto_link'])
            && is_array($this->extra['language_link'])
        ) {
            foreach($this->_site->getLanguages() as $lang) {
                $flag = ($this->extra['language_link'] && !empty($this->extra['language_link'][$lang]))
                    || $lang == $this->extra['language_standard'];
                if ($flag || $this->_site->admin['multi_lang']['auto_link']) {
                    $lang_page = $this->getLanguagePage($lang, array('deleted' => -1));
                    if (!is_object($lang_page)) {
                        continue;
                    }
                    $lang_page->restore();
                    if ($recursive) {
                        $pages = $lang_page->getDescendants(array(), array(
                            'deleted' => -1,
                            'children_query' => $query
                        ));
                        foreach ($pages as $page)
                        {
                            $page->restore();
                        }
                    }
                }
            }
        }
 
        if ($recursive) {
            $pages = $this->getDescendants(array(), array(
                'deleted' => -1,
                'children_param' => array('deleted' => -1),
                'children_query' => $query
            ));
            if ($pages->numRecords()>0) {
                $this->message = 'Diese Seite wurde inklusive Unterseiten erfolgreich wiederhergestellt.';
            }
            foreach ($pages as $page) {
                $page->restore();
            }
        }
 
        $this->replicate('undelete', $recursive, $query);
    }
 
    private function restore() {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'restore';
        }
 
        $inactive = $this->field['inactive'] == self::RELEASE_FLAG ?
            self::RELEASE_FLAG :
            self::INACTIVE_FLAG;
        if ($this->field['type'] == '_keywords/entry') {
            $inactive = self::ACTIVE_FLAG;
        }
        $field = array('inactive' => $inactive, 'deleted' => 0);
        if (!empty($this->field['url']) && !$this->isUniqueUrl($this->field['url'])) {
            // Beim Wiederherstellen wird die Meta URL gelöscht, wenn diese bereits verwendet wird
            $field['url'] = '';
        }
 
        // Ist die einzige Elternseite im Papierkorb oder existiert nicht, dann ist die Startseite die neue Elternseite
        $field['parents'] = $this->_site->rootId;
        foreach ($this->getParents(array(), array('deleted' => 0)) as $parent) {
            unset($field['parents']);
            break;
        }
 
        $this->updateField($field, false);
 
        $this->replicate('restore');
    }
 
    function unlinkFrom($remove_from) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'unlinkFrom';
        }
 
        $this->_removeParent($remove_from);
        if (!$this->field['deleted']) {
            // Prüfen ob noch weitere Parents vorhanden sind
            $parents = $this->getParents(array('fields' => 'id'), array(
                'sitemap' => true,
                'inactive' => true,
                'auth_or' => '1=1'
            ));
            if (!$parents->next()) {// Es sind keine Eltern mehr vorhanden.
                $this->delete();
            }
        }
 
        $this->replicate('unlinkFrom', $remove_from);
    }
 
    protected function _updateField($field, $update=true, $asis=false, $silent=false) {
        if (!$asis && $field['url'] && $field['id'] && $this->field['url'] != $field['url']) {
            $query = array(
                'table'     => $this->_site->name.'_'.$this->_site->language,
                'fields'    => 'id, url',
                'where'     => 'url=:url'.
                    ' AND deleted=0'.
                    ' AND id!=:id',
                'bind'  => array(
                    'url'   => $field['url'],
                    'id'    => $field['id']
                )
            );
            if ($this->extra['original_id']) {
                $query['where'].= ' AND id!=:originalid';
                $query['bind']['originalid'] = $this->extra['original_id'];
            }
            $db = new_db_connection($query);
            if ($db->nextRecord()) {
                $this->message.= $GLOBALS['auth']->translate('Die URL konnte nicht gespeichert werden, weil sie schon vorhanden ist!') . '\n';
                $field['url'] = $this->field['url'];
            }
        }
 
        // Multimedia Kategorien, Dateien und Bilder dürfen diese Zeichen nicht beinhalten: \/:*?"<>|
        if (isset($field['name'])) {
            $field['name'] = strip_tags($field['name']);
            if (in_array((isset($field['type']) ? $field['type'] : $this->field['type']), array('multimedia/category', 'multimedia/file', 'multimedia/image'))) {
                $field['name'] = strtr($field['name'], '\/:*?"<>|', '_________');
            }
        }
 
        // Kein HTML für Titel und Kurzbeschreibung
        if ($this->_site->admin['editor']['plaintext']) {
            if (isset($field['title'])) {
                $field['title'] = strip_tags($field['title']);
            }
            if (isset($field['short']) && !$this->_site->admin['editor']['short'] && !$GLOBALS['egotec_conf']['editor']['short']) {
                $field['short'] = strip_tags($field['short']);
            }
        }
 
        // Der Seitentyp darf nicht leer sein
        if (isset($field['type']) && empty($field['type'])) {
            $field['type'] = !empty($this->field['type']) ? $this->field['type'] : 'page';
        }
 
        $this->_cleanEmptyContent($field);
 
        $this->field = array_merge($this->field, $field);
        if ($update)
        {
            $this->_changeEntry($field, $asis, $silent);
        }
    }
 
    protected function _updateKeywords($asis = false) {
        // Nur wenn es ein Schlagwortregister gibt
        if ($this->_site->admin['keyword_register_own_site']) {
            $keywords = $this->_site->getPages(['where' => "type = '_keywords/list'"])->nextPage();
            if ($keywords) {
                // Alle Abkürzungen ermitteln (performant, ohne getDescendants)
                $abbreviations = $this->_site->getPages([], [
                    'extra' => "type = '_keywords/entry' AND deleted = 0 AND extra.abbreviation = 1"
                ]);
 
                // Unterschiede bei den zugeordneten Abkürzungen erkennen
                $old_abbreviations = [];
                $new_abbreviations = [];
                $current_abbreviations = $this->getParents([
                    'where' => "type = '_keywords/entry'"
                ]);
                foreach ($current_abbreviations as $current_abbreviation) {
                    if ($current_abbreviation->extra['abbreviation']) {
                        $old_abbreviations[] = $current_abbreviation->field['id'];
                    }
                }
 
                foreach ($abbreviations as $abbreviation) {
                    // Zu suchende Wörter
                    $words = [$abbreviation->field['name']];
 
                    // Synonyme ebenfalls suchen
                    if ($abbreviation->extra['synonym']) {
                        require_once 'base/Ego_Combo.php';
                        $combo = new Ego_Combo($abbreviation->extra['synonym']);
                        foreach ($combo->getText() as $text) {
                            $words[] = (string) $text;
                        }
                    }
 
                    // Rekursiv nach den Begriffen suchen
                    $search = function($value) use (&$search, $words) {
                        if (is_array($value)) {
                            foreach ($value as $v) {
                                if ($search($v)) {
                                    return true;
                                }
                            }
                        }
                        return is_string($value)
                            && preg_match('/>?[^<]*?\W*(' . implode('|', array_map(function($v) {
                                return preg_quote($v, '/');
                            }, $words)) . ')\W*[^>]*?<?/is', $value);
                    };
 
                    if (
                        $search($this->field['name'])
                        || $search($this->field['title'])
                        || $search($this->field['short'])
                        || $search($this->field['content'])
                        || $search($this->field['extra'])
                    ) {
                        // Schlagwort hinzufügen
                        if (!$this->hasParent($abbreviation->field['id'])) {
                            $this->addParent($abbreviation->field['id'], $asis);
                        }
                        $new_abbreviations[] = $abbreviation->field['id'];
                    } elseif ($this->hasParent($abbreviation->field['id'])) {
                        // Schlagwort entfernen
                        $this->delParent($abbreviation->field['id'], $asis);
                    }
                }
 
                $diff1 = array_diff($old_abbreviations, $new_abbreviations);
                $diff2 = array_diff($new_abbreviations, $old_abbreviations);
                return !empty($diff1) || !empty($diff2);
            }
        }
        return false;
    }
 
    protected function _updateChildren($children, $merge = true) {
        // Unterseiten beibehalten die nicht übergeben wurden, um verlorene Seiten zu vermeiden
        if ($merge) {
            $db = new_db_connection([
                'table' => $this->_site->pageTable . '_children',
                'where' => 'page_id = :page_id',
                'bind' => [
                    'page_id' => $this->field['id']
                ],
                'order' => 'idx ASC'
            ]);
            while ($db->nextRecord()) {
                if (!in_array($db->Record['child'], $children)) {
                    array_splice($children, (int)$db->Record['idx'], 0, $db->Record['child']);
                }
            }
        }
 
        $ancestors_iterator = $this->getAncestors(
            array('fields' => 'id'),
            array('auth_or' => '1=1', 'children_param' => array('auth_or' => '1=1'))
        );
        $ancestors = array();
        foreach ($ancestors_iterator as $ancestor_page)
        {
            $ancestors[] = $ancestor_page->field['id'];
        }
        $ancestors[] = $this->field['id'];
 
        $db = new_db_connection();
        $db->begin();
        $table = $this->_site->pageTable;
        $db->delete(array( // Alte Einträge löschen.
            'table' => $table.'_children',
            'where' => 'page_id='.$this->field['id']
        ));
        $children = array_unique($children); // Keine Seite mehrmals derselben Seite unterordnen.
        $idx = 0;
        foreach ($children as $child) {
            if ($child) { // Keine leeren Einträge.
                if (in_array($child, $ancestors)) { // Keine Endlosschleifen.
                    egotec_error_log('infinite loop prevention at children: '.$this->_site->pageTable.' '.$this->field['id'].','.$child);
                } else {
                    $db->insert(array(
                        'table' => $table.'_children',
                        'set'   => array('page_id' => $this->field['id'], 'idx' => $idx, 'child' => $child)
                    ));
                    $idx++;
                }
            }
        }
        $db->commit();
 
        $this->_updateCloneChildren();
 
        $this->_clearCache();
    }
 
    protected function _updateParents($parents) {
        if (empty($parents)) {
            egotec_error_log('empty parents: '.$this->_site->pageTable.$this->getTableSuffix().' '.$this->field['id']);
            return;
        }
        $current_parents = array();
        $db = new_db_connection(array(
            'table' => $this->_site->pageTable . '_children',
            'where' => 'child = :child',
            'bind' => array(
                'child' => $this->field['id']
            )
        ));
        while ($db->nextRecord()) {
            $current_parents[] = $db->Record['page_id'];
        }
        $num_parents = 0;
        $remove_parents = array();
        foreach ($current_parents as $current_parent) {
            $key = array_search($current_parent, $parents);
            if ($key!==false) { // Vorhandene Eltern in Ruhe lassen.
                unset($parents[$key]);
                $num_parents++;
            } else { // Nicht mehr vorhandene Eltern löschen.
                $remove_parents[] = $current_parent;
            }
        }
        foreach ($parents as $parent_id) { // Neue Eltern hinzufügen.
            if ($parent_id) {
                if ($parent_id!=$this->field['id']) {// Keine Endlosschleife erzeugen!
                    if ($this->_addParent($parent_id)) {
                        $num_parents++;
                    }
                } else {
                    egotec_error_log('infinite loop prevention at parents: '.$this->_site->pageTable.$this->getTableSuffix().' '.$this->field['id'].','.$parent_id);
                }
            }
        }
        if ($num_parents == 0) {
            egotec_error_log('empty parents 2: '.print_r($parents, true).' / '.$this->_site->pageTable.$this->getTableSuffix().' '.$this->field['id']);
            return;
        } else {
            // Eltern erst löschen, wenn es noch mindestens eine Elternseite gibt
            foreach ($remove_parents as $remove_parent) {
                $this->_removeParent($remove_parent);
            }
        }
    }
 
    private function _removeParent($parent_id) {
        $db = new_db_connection();
        $db->delete([
            'table' => $this->_site->pageTable.'_children',
            'where' => 'page_id = '.$parent_id.' AND child = '.$this->field['id']
        ]);
        $this->_site->clearCache();
 
        $parent = $this->_site->getPage($parent_id);
 
        if (isset($parent) && isset($this->extra['main_category']) && $this->extra['main_category'] == $parent->field['id']) {
            // Elternseite aus main_category dieser Seite entfernen
            unset($this->extra['main_category']);
            $this->update([], true, true);
        }
 
        // Wenn Parent ein Schlagwort ist, dann löschen wenn:
        // -> der Mandant des Klones die Checkbox "Neues Schlagwortregister verwenden" gesetzt hat
        // -> der verwendete Schlagwortregister nicht der Mandant des Klon Originals ist
        // -> das Schlagwort nicht mehr verwendet wird
        if ($parent && $parent->field['type'] == '_keywords/entry' && $parent->isClone()
            && $this->_site->admin['keyword_register_own_site'] && $parent->getCloneOriginal()->getSite()->name != $this->_site->admin['keywords']['site']
            && !$parent->hasChildren()) {
            $this->_deleteCloneKeywords($this, $parent);
        } elseif ($parent && $parent->extra['clones'] && !$this->isReleaseCopy() && !$this->isWorkflowCopy()) {
            // Elternseite existiert als Klon und hat geklonte Unterseiten
            $clones = explode(',', $parent->extra['clones']);
            foreach ($clones as $clone_url) {
                $parent_clone = Ego_System::urltopage(
                    $clone_url,
                    [
                        'params' => [
                            'param' => [
                                'auth_or' => '1=1',
                                'deleted_or' => '1=1',
                                'inactive' => true,
                                'only_active' => false
                            ]
                        ]
                    ]
                );
 
                // Prüfen ob geklonte Unterseiten oder deren Schlagwort Parents gelöscht werden sollen
                if ($parent_clone && ($parent->extra['clone_children_' . $clone_url] || $parent_clone->field['type'] == '_keywords/entry')) {
                    foreach ($parent_clone->getChildren([], [
                        'auth_or' => '1=1',
                        'deleted_or' => '1=1',
                        'inactive' => true,
                        'only_active' => false
                    ]) as $clone) {
                        if (in_array($clone->getCloneUrl(), explode(',', $this->extra['clones']))) {
                            // Wenn der Klon mehrere Parents hat, dann nur Parent aushängen statt komplett zu löschen
                            if ($clone->hasMultiParents()) {
                                $clone->delParent($parent_clone->field['id']);
 
                                // Wenn Parent ein Schlagwort ist, dann löschen wenn:
                                // -> der Mandant des Klones die Checkbox "Neues Schlagwortregister verwenden" gesetzt hat
                                // -> der verwendete Schlagwortregister nicht der Mandant des Klon Originals ist
                                // -> das Schlagwort nicht mehr verwendet wird
                                if ($parent_clone->field['type'] == '_keywords/entry' && !$parent_clone->hasChildren()
                                    && $clone->getSite()->admin['keyword_register_own_site']
                                    && $parent_clone->getCloneOriginal()->getSite()->name != $clone->getSite()->admin['keywords']['site']) {
                                    $this->_deleteCloneKeywords($clone, $parent_clone);
                                }
                            } else {
                                $clone->destroyClone();
                            }
                        }
                    }
                }
            }
        }
    }
 
    private function _addParent($parent_id) {
        if ($this->field['id']==$parent_id) { // Eine Endlosschleife vermeiden.
            egotec_error_log('infinite loop prevention: '.$this->_site->pageTable.$this->getTableSuffix().' '.$this->field['id'].','.$parent_id);
            return false;
        }
        $parent = $this->_site->getPage($parent_id, [
            'inactive' => true,
            'only_active' => false
        ]);
        if (!$parent) {
            return false;
        }
        $ancestors = $this->_getAncestorsIds(
            $parent,
            array('fields' => 'id'),
            array('auth_or' => '1=1')
        );
        if (in_array($this->field['id'], $ancestors)) { // Eine Endlosschleife vermeiden.
            return false;
        }
        if ($this->hasParent($parent_id)) { // Keine Seite mehrmals derselben Seite unterordnen.
            egotec_error_log('infinite loop prevention: '.$this->_site->pageTable.$this->getTableSuffix().' '.$this->field['id'].','.$parent_id);
            return false;
        }
        $db = new_db_connection();
        $db->select([ // höchsten Index der Kinder abfragen.
            'fields' => 'idx',
            'table' => $this->_site->pageTable . '_children',
            'where' => "page_id=" . $parent_id,
            'order' => 'idx DESC',
            'limit' => 1
        ]);
        $idx = $db->nextRecord() ? $db->Record['idx'] + 1 : 0;
        $db->replace([
            'table' => $this->_site->pageTable . '_children',
            'set' => ['page_id' => $parent_id, 'idx' => $idx, 'child' => $this->field['id']],
            'primary' => ['page_id', 'idx']
        ]);
 
        // Schlagwörter Parents aktualisieren/hinzufügen wenn das Original bearbeitet wird
        if ($parent && $parent->field['type'] == '_keywords/entry' && !$this->isClone()) {
            $my_clones = $this->getClones();
 
            foreach ($my_clones as $my_clone) {
                $this->_updateCloneKeywords($this, $my_clone);
            }
        } elseif ($parent && $parent->extra['clones'] && !$this->isReleaseCopy() && !$this->isWorkflowCopy()) {
            // Elternseite existiert als Klon und Unterseiten sollen ebenfalls geklont werden
            $clones = explode(',', $parent->extra['clones']);
            foreach ($clones as $clone_url) {
                $clone = Ego_System::urltopage(
                    $clone_url,
                    array(
                        'params' => array(
                            'param' => array(
                                'auth_or' => '1=1',
                                'deleted_or' => '1=1',
                                'inactive' => true,
                                'only_active' => false
                            )
                        )
                    )
                );
 
                // Prüfen ob Unterseiten geklont werden sollen
                if ($clone && $clone->isClone() && $parent->extra['clone_children_' . $clone_url]) {
                    // Wenn die Unterseite bereits geklont ist, dann Parent hinzufügen
                    $_clones = $this->getClones();
                    foreach ($_clones as $_clone) {
                        if (
                            $_clone->getSite()->name == $clone->getSite()->name
                            && !$_clone->hasParent($clone->field['id'])
                        ) {
                            $_clone->addParent($clone->field['id']);
                            continue 2;
                        }
                    }
 
                    $clone->createClone(
                        $this,
                        true,
                        $parent->extra['clone_rights_' . $clone_url],
                        $parent->extra['clone_release_' . $clone_url]
                    );
                }
            }
        }
 
        return true;
    }
 
    private function _clearCache($complete = false) {
        if ($this->archiveOnly) {
            // Cache nicht löschen, wenn es sich um eine Zwischenspeicherung handelt
            return;
        }
 
        $this->_site->clearCache(!$complete && $this->field['type'] == 'multimedia/image' ? $this->field['id'] : 0);
 
        // Die Cache aller verweisenden Seiten anderer Mandanten ebenfalls löschen
        $cleared = array();
        foreach ($this->getLinkedPages() as $link) {
            foreach ($link['sources'] as $site_name => $source) {
                if ($site_name != $this->_site->name && !in_array($site_name, $cleared)) {
                    $cleared[] = $site_name;
                    try {
                        $site = new Site($site_name);
                        Ego_Queue::add(array($site, 'clearCache'));
                    } catch (Site_Exception $e) {
                        // ignorieren
                    }
                }
            }
        }
    }
 
    protected function _updateClones(&$param) {
        if ($this->isReleaseCopy() || $this->isWorkflowCopy()) {
            return;
        }
        if ($param['extra']['clones'] || $this->extra['clones']) { // wenn ich Klone hab oder hatte
            $this_page_url = $this->getCloneUrl();
 
            if (isset($param['extra'])) {
                $folders = explode(',', $param['extra']['clones']);
                $param['extra']['clones'] = '';
                $old_clones = array_filter(array_unique(explode(',', $this->extra['clones'])));
 
                // wenn welche aus der liste entfernt wurden, löschen
                foreach ($old_clones as $old_c) {
                    if ($old_c == '') continue;
 
                    if (!in_array($old_c, $folders)) {
                        $clone = Ego_System::urltopage($old_c, array('params' => array('param' => array(
                            'auth_or' => '1=1',
                            'deleted_or' => '1=1',
                            'inactive' => true,
                            'only_active' => false
                        ))));
                        if ($clone) {
                            // Klon entfernen
                            $clone->delete();
                        }
                        unset($param['extra']['clone_children_' . $old_c], $param['extra']['clone_rights_' . $old_c], $param['extra']['clone_release_' . $old_c]);
                    }
                }
            } elseif (isset($this->extra['clones'])) {
                // Wenn extra nicht übergeben wird, dann mit dem aktuellen extra weitermachen
                $folders = array_filter(array_unique(explode(',', $this->extra['clones'])));
            } else {
                return;
            }
 
            // Sicherstellen, dass immer alle Daten vorhanden sind
            $param['field'] = $param['field'] ? $param['field'] : $this->field;
            $param['extra'] = $param['extra'] ? $param['extra'] : $this->extra;
 
            // Aktualisieren
            foreach ($folders as $f) {
                if (!$f) continue; // Leere überspringen
                $remove_parent = false;
 
                // Eltern holen
                $f_url = $f;
                $clone = Ego_System::urltopage($f, array('params' => array('param' => array(
                    'auth_or' => '1=1',
                    'deleted_or' => '1=1',
                    'inactive' => true,
                    'only_active' => false
                ))));
 
                if (!$clone) {
                    // Wenn der Klon nicht existiert, wird er dennoch beibehalten
                    $clones = array_filter(explode(',', $param['extra']['clones']));
                    $param['extra']['clones'] = implode(',', array_unique(array_merge($clones, array($f))));
                    continue;
                }
 
                $p = array(
                    'field' => $param['field'],
                    'extra' => $param['extra']
                );
                $p['extra']['clone_original'] = $this_page_url;
                unset($p['field']['id']);
                unset($p['field']['parents']);
                unset($p['field']['url']);
                unset($p['extra']['clones']);
 
                foreach ($p['extra'] as $key => $value) {
                    if (
                        strpos($key, 'clone_children_') === 0
                        || strpos($key, 'clone_rights_') === 0
                        || strpos($key, 'clone_release_') === 0
                    ) {
                        unset($p['extra'][$key]);
                    }
                }
 
                if (isset($p['extra']['main_category'])) {
                    $main_category = $this->_site->getPage($p['extra']['main_category'], [
                        'auth_or' => '1=1',
                        'deleted_or' => '1=1',
                        'inactive' => true,
                        'only_active' => false
                    ]);
 
                    unset($p['extra']['main_category']);
 
                    if ($main_category) {
                        $main_category_clones = $main_category->getClones();
                        $clone_parents = $clone->getParents([
                            'auth_or' => '1=1',
                            'deleted_or' => '1=1',
                            'inactive' => true,
                            'only_active' => false
                        ]);
 
                        foreach ($main_category_clones as $main_category_clone) {
                            foreach ($clone_parents as $clone_parent) {
                                if ($clone_parent->getIdentity() == $main_category_clone->getIdentity()) {
                                    $p['extra']['main_category'] = $clone_parent->field['id'];
                                    break 2;
                                }
                            }
                        }
                    }
                }
 
                if ($clone->isClone()) {
                    if (isset($clone->conf['edit_clone'])) {
                        // Nicht die Felder ändern, die bereits existieren und einen anderen Wert als den ursprünglichen haben
                        $combined_p = array();
                        foreach ($p as $field => $values) {
                            $combined_p[$field] = $values;
                            if (is_array($values) && isset($clone->conf['edit_clone'][$field])) {
                                $clone_edit = explode(',', $clone->conf['edit_clone'][$field]);
                                foreach ($clone_edit as $edit_key) {
                                    $value = Ego_System::getAssocValue($this->{$field}, $edit_key);
                                    if (
                                        ($clone_value = Ego_System::getAssocValue($clone->{$field}, $edit_key)) !== null
                                        && $clone_value != $value
                                    ) {
                                        // Wert beibehalten
                                        $value = $clone_value;
                                    }
                                    Ego_System::setAssocValue($combined_p[$field], $edit_key, $value);
                                }
                            }
                        }
                    } else {
                        // Alle Felder ändern
                        $combined_p = $p;
                    }
 
                    // Bei Freigabeklonen wird Freigabe ab und bis nicht mit denen vom Original überschrieben
                    $clone_page_url = $clone->getCloneUrl();
                    if ($param['extra']['clone_release_' . $clone_page_url]) {
                        unset($combined_p['field']['release_from'], $combined_p['field']['release_until']);
                    }
 
                    $clone->update($combined_p);
                } else { // es muss ein Klon erzeugt werden
                    $clone = $clone->newChild($p['field'], $p['extra']);
 
                    if (!$clone) {
                        continue;
                    }
                    $remove_parent = true;
                }
 
                // Original des Klones holen um Schlagwörter zu klonen
                $original = $clone->getCloneOriginal();
 
                // Schlagwörter Parents aktualisieren/hinzufügen
                if ($original) {
                    $this->_updateCloneKeywords($original, $clone);
                }
 
                // Mediapool kopieren
                $this->getMediapool()->copy($clone);
 
                // Klon merken
                $clone_page_url = $clone->getCloneUrl();
                $clones = array_filter(explode(',', $param['extra']['clones']));
                $param['extra']['clones'] = implode(',', array_unique(array_merge($clones, array($clone_page_url))));
 
                /* Übergebene Informationen verweisen auf die Elternseite des neuen Klons,
                 * diese verwerfen
                 */
                if ($remove_parent)
                {
                    $param['extra']['clone_children_' . $clone_page_url] = $param['extra']['clone_children_' . $f_url];
                    $param['extra']['clone_rights_' . $clone_page_url] = $param['extra']['clone_rights_' . $f_url];
                    $param['extra']['clone_release_' . $clone_page_url] = $param['extra']['clone_release_' . $f_url];
 
                    unset($param['extra']['clone_children_' . $f_url], $param['extra']['clone_rights_' . $f_url], $param['extra']['clone_release_' . $f_url]);
 
                    // Eingetragene Freigabe ab/bis Daten ändern
                    if ($param['extra']['clone_release_' . $clone_page_url]) {
                        $param['extra']['clone_release_from_' . $clone_page_url] = $param['extra']['clone_release_from_' . $f_url];
                        $param['extra']['clone_release_until_' . $clone_page_url] = $param['extra']['clone_release_until_' . $f_url];
 
                        unset($param['extra']['clone_release_from_' . $f_url], $param['extra']['clone_release_until_' . $f_url]);
                    }
                }
 
                // Die eingetragenen Freigabe ab/bis Daten verwenden
                if ($param['extra']['clone_release_'.$clone_page_url]) {
                    $clone_release = array();
 
                    if ($param['extra']['clone_release_from_' . $clone_page_url]) {
                        $clone_release['release_from'] = $param['extra']['clone_release_from_' . $clone_page_url];
                    } else {
                        $clone_release['release_from'] = '0000-00-00 00:00:00';
                    }
 
                    if ($param['extra']['clone_release_until_' . $clone_page_url]) {
                        $clone_release['release_until'] = $param['extra']['clone_release_until_' . $clone_page_url];
                    } else {
                        $clone_release['release_until'] = '0000-00-00 00:00:00';
                    }
 
                    if (!empty($clone_release)) {
                        $clone->updateField($clone_release);
                    }
                }
 
                // Informationen zu Freigabe ab/bis des Klons nicht merken
                unset(
                    $param['extra']['clone_release_from_' . $clone_page_url],
                    $param['extra']['clone_release_until_' . $clone_page_url]
                );
 
                // Prüfen ob an Klonen mit Unterseiten etwas geändert worden ist
                if (
                    $param['extra']['clone_children_'.$clone_page_url] != $this->extra['clone_children_'.$clone_page_url]
                    || $param['extra']['_update_child_clones'] // Klon Unterseiten in jeden Fall aktualisieren
                )
                {
                    unset($param['extra']['_update_child_clones']);
                    if ($param['extra']['clone_children_'.$clone_page_url] == 1)
                    {
                        // Klon Kinder für diesen Klon erstellen
                        $this->_createChildClones($clone);
                    }
                    else
                    {
                        // Klon Kinder dieses Klons entfernen
                        $this->_destroyChildClones($clone);
                    }
                }
            }
        } elseif ($this->isClone()) {
            // Ist diese Seite ein Klon und funktioniert als Verknüpfung, dann das Original auch speichern
            $type_info = $this->getTypeInfo();
            if (
                $type_info['clone_link']
                && ($page = Ego_System::urltopage($this->extra['clone_original'], array('params' => array('param' => array(
                    'auth_or' => '1=1',
                    'deleted_or' => '1=1',
                    'inactive' => true,
                    'only_active' => false
                )))))
            ) {
                $p = array(
                    'field' => $param['field'],
                    'extra' => $param['extra']
                );
                $p['extra']['clones'] = $page->extra['clones'];
                foreach ($page->extra as $key => $value) {
                    if (
                        strpos($key, 'clone_children_') === 0
                        || strpos($key, 'clone_rights_') === 0
                        || strpos($key, 'clone_release_') === 0
                    ) {
                        $p['extra'][$key] = $value;
                    }
                }
                unset($p['field']['id']);
                unset($p['field']['parents']);
                unset($p['field']['url']);
                unset($p['extra']['clone_original']);
                $page->update($p);
 
                // Mediapool kopieren
                $this->getMediapool()->copy($page);
            }
        }
    }
 
    public function getClones($target_site = 'all') {
        $clones = [];
        $clone_array = array_filter(array_unique(explode(',', $this->extra['clones'])));
        foreach ($clone_array as $clone_index) {
            if ($clone_index == '') continue;
            $clone = Ego_System::urltopage($clone_index, array('params' => array('param' => array(
                'auth_or' => '1=1',
                'deleted_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ))));
            if (($clone && $target_site == 'all') || ($clone && $target_site != 'all' && $target_site == $clone->getSite()->name)) {
                $clones[] = $clone;
            }
        }
        return $clones;
    }
 
    public function createClone($page, $children = false, $rights = false, $release = false, $multiple = true) {
        $_REQUEST['var']['reload_dlg'] = true; // Wird die Methode in einem Action Hook aufgerufen, muss das dlg neu geladen werden
        return $this->_createClone($page, $children, $rights, $release, $multiple);
    }
 
    protected function _createClone($page, $children = false, $rights = false, $release = false, $multiple = true) {
        $clone_url = $page->getCloneUrl();
 
        if (!$multiple) {
            // Prüfen, ob es diesen Klon bereits gibt
            $children2 = $this->getChildren(array(), array(
                'auth_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ));
            foreach ($children2 as $child) {
                if ($child->extra['clone_original'] == $clone_url) {
                    return $child;
                }
            }
        }
 
        // Neuen Klon erstellen
        $p = array(
            'field' => $page->field,
            'extra' => $page->extra
        );
        $p['extra']['clone_original'] = $clone_url;
        unset($p['field']['id']);
        unset($p['field']['parents']);
        unset($p['field']['url']);
        unset($p['extra']['clones']);
 
        $clone = $this->newChild($p['field'], $p['extra']);
 
        // Neuen Klon auf dieser Seite eintragen
        $extra = $page->extra;
 
        $clones = array_filter(explode(',', $extra['clones']));
        $clone_page_url = $clone->getCloneUrl();
 
        $extra['clones'] = implode(',', array_unique(array_merge($clones, array($clone_page_url))));
        if ($children) {
            $extra['clone_children_' . $clone_page_url] = 1;
        }
        if ($rights) {
            $extra['clone_rights_' . $clone_page_url] = 1;
        }
        if ($release) {
            $extra['clone_release_' . $clone_page_url] = 1;
        }
 
        /* Die Klon Einstellungen müssen bereits jetzt in der Datenbank bekannt sein, damit Unterseiten,
         * die ebenfalls geklont werden, beim Ermitteln der Klone Elternseite die Klone auch finden können.
         * Nur so kann z.B. die "main_category" für den Klon angepasst werden.
         * Dabei auch keine "asis" Archive anlegen. */
        $page->updateExtra($extra, true, true, true);
 
        // Nicht für Schlagwörter, da dies geklonte Schlagwörter unter der jeweiligen Seite löschen würde
        if (strpos($page->field['type'], '_keywords/') !== 0) {
            $page->extra['_update_child_clones'] = true; // Klon Unterseiten in jeden Fall aktualisieren
        }
        $page->update();
 
        $this->_updateCloneKeywords($page, $clone);
 
        return $clone;
    }
 
    protected function _updateCloneRights() {
        if (isset($this->extra['clones']) && !$this->isClone()) {
            foreach (explode(',', $this->extra['clones']) as $clone_url) {
                if (!empty($this->extra['clone_rights_'.$clone_url])) {
                    $clone = Ego_System::urltopage($clone_url, array('params' => array('param' => array(
                        'auth_or' => '1=1',
                        'inactive' => true,
                        'only_active' => false
                    ))));
                    if ($clone) {
                        $clone->setRightsArray($this->getRightsArray());
                        $clone->setUsersArray($this->getUsersArray());
                    }
                }
            }
        }
    }
 
    protected function _updateCloneChildren() {
        if ($this->field['children_order'] == 'children' && isset($this->extra['clones']) && !$this->isClone()) {
            foreach (explode(',', $this->extra['clones']) as $clone_url) {
                if ($this->extra['clone_children_'.$clone_url]) {
                    $clone = Ego_System::urltopage($clone_url, array('params' => array('param' => array(
                        'auth_or' => '1=1',
                        'inactive' => true,
                        'only_active' => false
                    ))));
                    if ($clone) {
                        $clone_children = [];
                        $children = $this->getChildren([], [
                            'auth_or' => '1=1',
                            'inactive' => true,
                            'only_active' => false
                        ]);
 
                        foreach ($children as $child) {
                            if (!empty($child->extra['clones'])) {
                                foreach (explode(',', $child->extra['clones']) as $clone_child_url) {
                                    $clone_child = Ego_System::urltopage($clone_child_url, ['params' => ['param' => [
                                        'auth_or' => '1=1',
                                        'inactive' => true,
                                        'only_active' => false
                                    ]]]);
                                    if ($clone_child) {
                                        $clone_child_parents = $clone_child->getParents([], [
                                            'auth_or' => '1=1',
                                            'inactive' => true,
                                            'only_active' => false
                                        ]);
                                        foreach ($clone_child_parents as $clone_child_parent) {
                                            if ($clone_child_parent->getIdentity() == $clone->getIdentity()) {
                                                $clone_children[] = $clone_child->field['id'];
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
 
                        if (!empty($clone_children)) {
                            $clone->updateChildren($clone_children);
                        }
                    }
                }
            }
        }
    }
 
    protected function _createChildClones($parent) {
        // Kinder dieser Seite
        $children = $this->getChildren(array(), array(
            'auth_or' => '1=1',
            'inactive' => true,
            'only_active' => false
        ));
 
        foreach($children as $child) {
            // Klone des Kindes prüfen ob bereits der Zielparent (im gleichen Mandanten) gesetzt ist
            // Wenn nicht, dann Parent hinzufügen
            $clones = $child->getClones();
 
            foreach ($clones as $clone) {
                if (
                    $clone->getSite()->name == $parent->getSite()->name
                    && !$clone->hasParent($parent->field['id'])
                ) {
                    $clone->addParent($parent->field['id']);
                    continue 2;
                }
            }
 
            // Klon nur anlegen falls es noch nicht existiert
            $clone_child = $parent->getChildren(
                array(
                    'where' => 'name=:n AND a_date=:a',
                    'bind' => array(
                        'n' => $child->field['name'],
                        'a' => $child->field['a_date']
                    )
                ),
                array(
                    'inactive' => true
                )
            );
 
            if (!$clone_child->numRecords()) {
                $parent->createClone(
                    $child,
                    true,
                    !!$this->extra['clone_rights_'.$parent->getCloneUrl()],
                    !!$this->extra['clone_release_'.$parent->getCloneUrl()]
                );
            }
        }
    }
 
    protected function _updateCloneKeywords($original, $clone) {
        if ($clone->field['type'] != '_keywords/entry') {
            $keywords = $original->getParents(['where' => "type = '_keywords/entry'"]);
 
            if ($keywords) {
                foreach ($keywords as $keyword) {
                    $clones_keyword = $keyword->getClones($clone->getSite()->name);
                    // Wenn kein Klon von diesem Schlagwort auf dem Ziel Mandanten existiert und dieser das neue Schlagwortregistermodul verwendet
                    if ($clone->getSite()->admin['keyword_register_own_site'] && empty($clones_keyword)) {
                        $keyword_list = $clone->getSite()->getPages(['where' => "type = '_keywords/list'"])->nextPage(); // Schlagwortregister auf dem Ziel Mandanten
 
                        $createCloneKeywords = function($keyword_list, $keyword, $siteName) {
                            if (empty($keyword->getClones($siteName))) {
                                $current_keyword = $keyword; // derzeitiges Schlagwort
                                $parent_keywords = []; // Schlagwort Parents
 
                                // alle Schlagwort Parents durchgehen
                                while ($current_keyword = $current_keyword->getParents(['where' => "type = '_keywords/entry'"])->nextPage()) {
                                    array_unshift($parent_keywords, $current_keyword);
                                }
 
                                // wenn Schlagwort Parents existieren
                                if (!empty($parent_keywords)) {
                                    foreach ($parent_keywords as $key => $parent_keyword) {
                                        // Wenn noch kein Klon auf dem Mandanten existiert, dann lege diesen an
                                        if (!$parent_keyword->getClones($siteName)) {
                                            if ($key == 0) {
                                                // Schlagwort unter Schlagwortregister klonen
                                                $current_keyword = $keyword_list->createClone($parent_keyword);
                                            } else {
                                                // Schlagwort unter Parents klonen
                                                $current_keyword = $current_keyword->createClone($parent_keyword);
                                            }
                                        } else {
                                            // Wenn bereits ein Klon auf dem Mandanten existiert, dann verwende diesen als $current_keyword weiter
                                            $current_keyword = $parent_keyword->getClones($siteName)[0];
                                        }
                                    }
 
                                    // Schlagwort unter Parents klonen
                                    $current_keyword->createClone($keyword);
                                } else {
                                    // Schlagwort unter Schlagwortregister klonen
                                    $keyword_list->createClone($keyword);
                                }
                            }
                        };
 
                        // Führe es einmal für den Zielmandanten aus damit diese Schlagwörter dem Klon hinzugefügt werden können
                        $createCloneKeywords($keyword_list, $keyword, $keyword_list->getSite()->name);
 
                        // Dann nochmal für das Original und eventuelle weitere Klone
                        if ($keyword_list->isClone()) {
                            $original_keyword_list = $keyword_list->getCloneOriginal();
 
                            $createCloneKeywords($original_keyword_list, $keyword, $original_keyword_list->getSite()->name);
 
                            foreach ($original_keyword_list->getClones() as $keyword_list_clone) {
                                if ($keyword_list->getSite()->name != $keyword_list_clone->getSite()->name) {
                                    $createCloneKeywords($keyword_list_clone, $keyword, $keyword_list_clone->getSite()->name);
                                }
                            }
                        }
 
                        $clones_keyword = $keyword->getClones($clone->getSite()->name);
                    }
 
                    if ($clones_keyword) {
                        // Schlagwörter Klone durchgehen und ggf. als Parent hinzufügen
                        foreach ($clones_keyword as $clone_keyword) {
                            if (!$clone->hasParent($clone_keyword->field['id'])) {
                                $clone->addParent($clone_keyword->field['id']);
                            }
                        }
                    }
                }
            }
        }
    }
 
    protected function _deleteCloneKeywords($clone_check, $clone_to_delete) {
        $current_keyword = $clone_to_delete;
        $parent_keywords = [];
 
        while ($current_keyword = $current_keyword->getParents(['where' => "type = '_keywords/entry'"])->nextPage()) {
            $parent_keywords[] = $current_keyword;
        }
 
        $clone_to_delete->destroyClone();
 
        if (!empty($parent_keywords)) {
            foreach ($parent_keywords as $parent_keyword) {
                // Wenn Parent ein Schlagwort ist, dann löschen wenn:
                // -> der Mandant des Klones die Checkbox "Neues Schlagwortregister verwenden" gesetzt hat
                // -> der verwendete Schlagwortregister nicht der Mandant des Klon Originals ist
                // -> das Schlagwort nicht mehr verwendet wird
                if ($parent_keyword->field['type'] == '_keywords/entry' && !$parent_keyword->hasChildren()
                    && $clone_check->getSite()->admin['keyword_register_own_site']
                    && $parent_keyword->getCloneOriginal()->getSite()->name != $clone_check->getSite()->admin['keywords']['site']) {
                    $parent_keyword->destroyClone();
                }
            }
        }
    }
 
    protected function _destroyChildClones($parent) {
        // Kinder dieser Seite
        $children = $this->getChildren(array(), array(
            'auth_or' => '1=1',
            'inactive' => true,
            'only_active' => false
        ));
 
        foreach($children as $child) {
            // Klon nur entfernen falls es existiert
            $clone_child = $parent->getChildren(
                array(
                    'where' => 'name=:n AND a_date=:a',
                    'bind' => array(
                        'n' => $child->field['name'],
                        'a' => $child->field['a_date']
                    )
                ),
                array(
                    'inactive' => true
                )
            );
 
            if ($clone = $clone_child->nextPage()) { // Klon entfernen
                $clone->destroyClone();
            }
        }
    }
 
    public function destroyClone() {
        $_REQUEST['var']['reload_dlg'] = true; // Wird die Methode in einem Action Hook aufgerufen, muss das dlg neu geladen werden
        return $this->_destroyClone();
    }
 
    protected function _destroyClone() {
        $page = $this->getCloneOriginal();
        if (!$page) {
            return false;
        }
        $extra = $page->extra;
        $clones = explode(',', $extra['clones']);
        $clone_page_url = $this->getCloneUrl();
        if (!in_array($clone_page_url, $clones)) {
            return false;
        }
 
        $new_clones = array();
        foreach($clones as $c) {
            if ($c != $clone_page_url) {
                $new_clones[] = $c;
            }
        }
 
        $extra['clones'] = implode(',', array_filter(array_unique($new_clones)));
        unset($extra['clone_children_' . $clone_page_url], $extra['clone_release_' . $clone_page_url]);
 
        $page->updateExtra($extra);
        $this->delete();
 
        return true;
    }
 
    protected function _updateRights($rights, $asis = false) {
        $db = new_db_connection();
        if ($rights['_delete']) {
            $delete_query_where = ' AND perm in (\''.join('\',\'', $rights['_delete']).'\')';
            unset($rights['_delete']);
        }
        $rights['rights'] = array_merge($this->getRightsArray(),$rights['rights']);
        if ($rights['rights']) { // Gruppen und Rollen.
            $db->delete(array( // Alte Einträge löschen.
                'from'  => $this->_site->pageTable.'_rights',
                'where' => 'page_id='.$this->field['id'].$delete_query_where
            ));
            foreach ($rights['rights'] as $right => $groups) {
                $is_null = true; // Zunächst von keiner Beschränkung ausgehen.
                foreach ($groups as $group) {
                    if (!$group['group_id'] || !$group['role_id']) {
                        if ($rights['users'] && $rights['users'][$right] && count($rights['users'][$right]) != 0) {
                            // es sind user vorhanden aber keine Group/Role Kombination
                            $group['group_id'] = $GLOBALS['egotec_conf']['superuser']['group'];
                            $group['role_id'] = $GLOBALS['egotec_conf']['superuser']['role'];
                        }
                    }
 
                    if ($group['group_id'] && $group['role_id']) { // Keine leeren Einträge setzen.
                        $db->replace(array(
                            'table' => $this->_site->pageTable.'_rights',
                            'set'   => array(
                                'page_id'   => $this->field['id'],
                                'perm'      => $right,
                                'group_id'  => $group['group_id'],
                                'role_id'   => $group['role_id']
                            ),
                            'primary'   => array('page_id', 'perm', 'group_id', 'role_id')
                        ));
                        $is_null = false; // Es wurde eine Beschränkung gesetzt.
                    }
                }
                if ($is_null && strpos(Auth::NO_NULL_RIGHTS, ','.$right.',')!==false) { // Bei einem Recht, das nicht per IS NULL abgefragt wird
                    $db->replace(array(
                        'table' => $this->_site->pageTable.'_rights',
                        'set'   => array(
                            'page_id'   => $this->field['id'],
                            'perm'      => $right,
                            'group_id'  => '*', // *|* setzen.
                            'role_id'   => '*'
                        ),
                        'primary'   => array('page_id', 'perm', 'group_id', 'role_id')
                    ));
                }
            }
        }
 
        if ($rights['users']) {
            // Benutzer.
            $db->delete(array( // Alte Einträge löschen.
                'from'  => $this->_site->pageTable.'_users',
                'where' => "page_id=".$this->field['id'].$delete_query_where
            ));
            foreach ($rights['users'] as $right => $users) {
                if (is_array($users)) {
                    foreach ($users as $user) {
                        if ($user['user_id']) { // Leere Einträge vermeiden
                            $db->insert(array(
                                'table' => $this->_site->pageTable.'_users',
                                'set'   => array(
                                    'page_id'   => $this->field['id'],
                                    'perm'      => $right,
                                    'user_id'   => trim($user['user_id'],"'"),
                                )
                            ));
                        }
                    }
                }
            }
        }
 
        // Multimedia Bilder vererben das Ansichtsrecht an alle Bildausschnitte
        if ($this->field['type'] == 'multimedia/image') {
            $children = $this->getChildren(array(
                'where' => "type = 'multimedia/image'"
            ), array(
                'auth_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ));
            foreach ($children as $child) {
                if ($child->extra['crop_image']) {
                    $child->update(array(
                        'rights' => array(
                            'rights' => array(
                                'view' => $rights['rights']['view'] ? $rights['rights']['view'] : array()
                            ),
                            'users' => array(
                                'view' => $rights['users']['view'] ? $rights['users']['view'] : array()
                            )
                        )
                    ));
                }
            }
        }
 
        // Die eingetragenen Rechte klonen
        if (!$asis) {
            $this->_updateCloneRights();
        }
 
        if (!isset($this->field['inactive']) || !$this->field['inactive']) {
            $this->_clearCache();
        }
    }
 
    protected function _update($param, $matrix_flag = true, $asis = false, $silent = false) {
        $language_standard = $this->extra['language_standard'];
 
        // Automatisch übersetzen
        $param = $this->autoTranslate($param, $this->_site->language, !($param['translate_no_diff'] === true));
 
        if (!$asis) { // @TODO Ist das notwendig?
            $this->_updateClones($param);
        }
 
        if (isset($param['extra']) && $param['field'] && (int)$param['extra']['original_id']) { // Workflowkopien sind immer inaktiv;
            $param['field']['inactive'] = $this->isReleaseCopy() ? self::RELEASE_FLAG : self::INACTIVE_FLAG;
        }
        if (isset($param['extra'])) {
            $new_extra = array();
            if (is_array($param['extra'])) {
                $new_extra = Ego_System::cleanTypes($param['extra']);
 
                $area_password_changed = 0;
                if($new_extra['area_pw'] != '') {
                    $salt = sha1($this->field['id']);
                    $new_extra['area_password'] = crypt($new_extra['area_pw'], '$6$rounds=5000$' . $salt . '$');
                    $area_password_changed = 1;
                }
 
                if ($new_extra['area_pw_reset'] == true) {
                    unset($new_extra['area_pw_reset']);
                    unset($new_extra['area_password']);
                    $area_password_changed = 2;
                }
 
                unset($new_extra['area_pw']);
 
                if ($area_password_changed > 0) {
                    foreach ($this->getChildren() as $child) {
                        $child_extra = $child->extra;
                        switch ($area_password_changed) {
                            case 1:
                                $child_extra['area_password'] = $new_extra['area_password'];
                                break;
                            case 2:
                                unset($child_extra['area_password']);
                        }
                        $child->updateExtra($child_extra, true, $asis, $silent);
                    }
                }
            }
 
            // Vererbte Blöcke nicht speichern
            if (!empty($new_extra['_inherited'])) {
                $blocks = $new_extra['_blocks'];
                $contents = $new_extra['_contents'];
                foreach ($new_extra['_inherited'] as $orient => $checksum) {
                    if ($blocks[$orient] && $contents[$orient]) {
                        $checksum_blocks = Ego_System::getChecksum($blocks[$orient]);
                        $checksum_contents = Ego_System::getChecksum($contents[$orient]);
                        if ($checksum_blocks == $checksum['blocks'] && $checksum_contents == $checksum['contents']) {
                            unset($new_extra['_blocks'][$orient], $new_extra['_contents'][$orient]);
                        }
                    }
                }
            }
 
            unset($new_extra['_inherited']);
            if (!$asis) {
                unset($new_extra['_asis']);
            }
            $param['extra'] = $new_extra;
        }
        if ($param['field'] || $param['extra']) {
            // Der Seitentyp wird gewechselt
            if (
                !empty($param['field']['type'])
                && $param['field']['type'] != $this->field['type']
                && $this->isFrontendAdmin()
            ) {
                $this->field['type'] = $param['field']['type'];
                $this->_loadConfig();
                if (!empty($this->conf['default_layout'])) {
                    // Das Standard Layout des neuen Seitentyps verwenden
                    $param['extra'] = isset($param['extra'])
                        ? $param['extra']
                        : $this->extra;
                    $param['extra']['_layout'] = $this->conf['default_layout'];
                }
            }
 
            if ($param['field']['children']) {
                if (!isset($param['children'])) {
                    $param['children'] = explode(',', trim($param['field']['children'], ','));
                }
                unset($param['field']['children']);
            }
            if ($param['field']['parents']) {
                if (!isset($param['parents'])) {
                    $param['parents'] = explode(',', trim($param['field']['parents'], ','));
                }
                unset($param['field']['parents']);
            }
 
            if (isset($param['extra'])) {
                $param['field']['extra'] = serialize($param['extra']);
            }
 
            $this->_updateField($param['field'], true, $asis, $silent);
        }
 
        // Mediapool Aktionen ausführen
        if ($param['pool']) {
            // Dateien umbenennen
            if (is_array($param['pool']['rename'])) {
                foreach ($param['pool']['rename'] as $info) {
                    if ($info['name'] != $info['new_name']) {
                        $this->getMediapool()->edit($info['name'], array(
                            'new_name' => $info['new_name']
                        ), (string) $info['dir']);
                    }
                }
            }
        }
 
        if ($param['children']) {
            $this->_updateChildren($param['children'], !($param['merge_children'] === false));
        }
        if ($param['parents'] && $this->field['id'] != $this->_site->rootId) {
            $this->_updateParents($param['parents']);
        }
 
        if ($param['rights']) {
            $this->_updateRights($param['rights'], $asis);
        }
 
        // Schlagwörter automatisch hinzufügen
        $reload = $this->_updateKeywords($asis);
 
        if (
            !$this->isClone()
            && !$this->extra['crop_image'] // Ausschnitte legen keine Archive oder Sprachen an
            && !$silent
        ) {
            // Archiv anlegen
            $this->_archiveEntry();
 
            // Die Inhalte der Standardsprache in die verknüpften Bereiche speichern.
            if (
                !$this->archiveOnly // Nicht für Zwischenspeicherungen
                && !$this->isWorkflowCopy()
                && $matrix_flag
                && $language_standard == $this->_site->language
                && is_array($param['extra']['language_link'])
            ) {
                $clean_clones = function($extra) {
                    unset($extra['clones'], $extra['area_domain']);
                    foreach (array_keys($extra) as $key) {
                        if (strpos($key, 'clone_') === 0) {
                            unset($extra[$key]);
                        }
                    }
                    return $extra;
                };
 
                $languages = array();
                $site_languages = $this->_site->getLanguages();
                foreach ($site_languages as $lang) {
                    // #173630: Nur wenn es die Sprache auch noch gibt
                    $matrix_page = $this->getLanguagePage($lang, array(
                        'deleted' => -1,
                        'inactive' => 1,
                        'only_active' => false,
                        'auth_or' => '1=1'
                    ));
                    $flag = $param['extra']['language_link'][$lang];
                    if ($flag && $lang!=$this->_site->language) {
                        if ($matrix_page) {
                            $param['extra'] = $clean_clones(array_merge($this->extra, $param['extra']));
                            if (!isset($param['rights'])) {
                                $param['rights'] = [
                                    'rights' => $this->getRightsArray(),
                                    'users' => $this->getUsersArray()
                                ];
                            }
 
                            $matrix_param = $param;
                            if (!empty($param['extra']['language_urls'][$lang])) {
                                $matrix_param['field']['url'] = $param['extra']['language_urls'][$lang];
                            }
 
                            // Meta URL für Sprachverknüpfung setzen
                            $matrix_page->update($matrix_param, false, $asis, $silent);
 
                            // Mediapool kopieren
                            $this->getMediapool()->copy($matrix_page, '', false, false, true, true, false, '', false);
 
                            // Wenn bereits eine Sprachkopie existiert und darauß eine Sprachverknpüfung wird, dann alle Multimedia Dateien löschen
                            if ($this->_site->site['type'] == 'media') {
                                $media_dir = $GLOBALS['egotec_conf']['var_dir'] . 'media' . DIRECTORY_SEPARATOR . $this->_site->name;
                                $source = $media_dir . DIRECTORY_SEPARATOR . $matrix_page->getMediaFilename(true);
 
                                foreach (glob($source . '*') as $media_file) {
                                    @unlink($media_file);
                                }
                            }
                        } elseif (!$this->isReleaseCopy()) { // Wenn die Seite noch nicht in dieser Sprache vorhanden ist, dann wird diese erzeugt (außer für Freigabekopien).
                            $matrix_parent = $this->getParents(array(), array('auth_or' => '1=1'));
                            if ($matrix_parent) {
                                $matrix_parent = $matrix_parent->nextPage(); /* @var $matrix_parent Page */
                                if ($matrix_parent) {
                                    $matrix_parent = $matrix_parent->getLanguagePage($lang, array(
                                        'auth_or' => '1=1',
                                        'inactive' => 1,
                                        'only_active' => false,
                                        'deleted_or' => '1=1'
                                    ));
                                    if ($matrix_parent)
                                    {
                                        if ($matrix_parent->field['deleted']) {
                                            // Elternseite wiederherstellen
                                            $matrix_parent->undelete();
                                        }
                                        if ($matrix_page = $matrix_parent->newChild($this->field, $clean_clones($this->extra))) {
                                            // Mediapool kopieren
                                            $this->getMediapool()->copy($matrix_page, '', false, false, true, true, false, '', false);
                                        }
                                    }
                                }
                            }
                        }
                        $languages[] = $lang;
                    }
                    elseif (!$this->field['deleted'] && $lang!=$this->_site->language) {
                        // #204196: Nur wenn diese Sprache keine Sprachverknüpfung (und nicht gelöscht) ist
                        if ($matrix_page) {
                            if (
                                !Ego_System::isEqual($matrix_page->extra['language_link'], $param['extra']['language_link'])
                                || !Ego_System::isEqual($matrix_page->extra['language_standard'], $param['extra']['language_standard'])
                            ) {
                                $matrix_page_link = $matrix_page->extra['language_link'][$lang];
 
                                $matrix_page_extra = $matrix_page->extra;
                                $matrix_page_extra['language_link'] = $param['extra']['language_link'];
                                $matrix_page_extra['language_standard'] = $param['extra']['language_standard'];
 
                                $matrix_page->updateExtra($clean_clones($matrix_page_extra), false, $asis, $silent);
 
                                // Aus einer existierenden Sprachverknüpfung wird eine Sprachkopie
                                if (!$param['extra']['language_link'][$lang] && $matrix_page_link) {
                                    // Multimedia Dateien müssen kopiert werden
                                    if ($this->_site->site['type'] == 'media') {
                                        $media_dir = $GLOBALS['egotec_conf']['var_dir'] . 'media' . DIRECTORY_SEPARATOR . $this->_site->name;
                                        $source = $media_dir . DIRECTORY_SEPARATOR . $this->getMediaFilename();
 
                                        if (Ego_System::file_exists($source)) {
                                            $dest = $media_dir . DIRECTORY_SEPARATOR . $matrix_page->getMediaFilename(true);
                                            Ego_System::copy(
                                                $source,
                                                $dest,
                                                '',
                                                true
                                            );
 
                                            // Archiveintrag
                                            Ego_System::copy(
                                                $dest,
                                                $media_dir . DIRECTORY_SEPARATOR . $matrix_page->getMediaFilename(
                                                    true,
                                                    '_'.strtotime($matrix_page->field['m_date'])
                                                ),
                                                '',
                                                true
                                            );
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if ($languages)
                {
                    $this->message.= "\n".$GLOBALS['auth']->translate('Folgende Sprachen wurden auch geändert:').' '.join(', ', $languages)."\n";
                    $this->_updatedLinkLanguages = $languages;
                }
            }
        }
 
        // Wird ein Multimedia Bild gespeichert, muss für alle untergeordneten Ausschnitte
        if ($this->field['type'] == 'multimedia/image') {
            foreach ($this->getChildren() as $child) {
                // ... die Spracheinstellungen vererbt werden
                if (isset($param['extra'])) {
                    $extra = $child->extra;
                    $extra['language_link'] = $param['extra']['language_link'];
                    $extra['language_standard'] = $param['extra']['language_standard'];
                    $child->updateExtra($extra, true, $asis, $silent);
                }
 
                // ... der Cache gelöscht werden
                $this->_site->clearCache($child->field['id']);
            }
        }
 
        $this->hookUpdate();
        $this->updateIndex();
 
        // Bilder umwandeln
        Ego_Queue::add([$this, 'convertImages']);
 
        return $reload;
    }
 
    function hookUpdate($hook = 'update') {
        // Zwischenspeicherungen führen keine Hooks aus
        if ($hook == 'update' && $this->archiveOnly) {
            return;
        }
 
        $cache_key = $this->_site->name.'/'.$this->field['type'].'/'.$hook;
        $hook_cache = array();
        if (isset($GLOBALS['hook_cache'][$cache_key])) {
            $hook_cache = $GLOBALS['hook_cache'][$cache_key];
        } else {
            $dirs = array(
                $GLOBALS['egotec_conf']['lib_dir'] . 'type/site/' => 0, // System
                $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme.'/site/' => 'theme', // pub theme
                $GLOBALS['egotec_conf']['site_dir'] . '_global/' => 'global', // Global
                $GLOBALS['egotec_conf']['site_dir'] . $this->_site->name . '/' => 'misc' // Mandant
            );
            foreach ($dirs as $dir => $flag) {
                if ($flag == 'global' && !$this->_site->globalAllowed()) {
                    continue;
                }
                $script_path = $dir . 'admin/' . $hook . '.php';
                if ($flag && Ego_System::file_exists($script_path)) {
                    $hook_cache[] = array('path' => $script_path, 'flag' => $flag, 'type' => false);
                }
                $script_path = $dir . $this->field['type'] . '/admin/' . $hook . '.php';
                if (Ego_System::file_exists($script_path)) {
                    $hook_cache[] = array('path' => $script_path, 'flag' => $flag ? $flag : 'misc', 'type' => true);
                }
            }
            if (!isset($GLOBALS['hook_cache'])) {
                $GLOBALS['hook_cache'] = array();
            }
            $GLOBALS['hook_cache'][$cache_key] = $hook_cache;
        }
        if ($hook_cache) {
            if (!$this->field['type']) {
                throw new Exception();
            }
            foreach ($hook_cache as $script_path) {
                $call_func = $script_path['type']
                    ? 'site_'.$hook.'_'.str_replace('/', '_', $this->field['type']).'_'.$script_path['flag']
                    : 'site_' . $hook . '_' . $script_path['flag'];
                if (!function_exists($call_func)) {
                    require_once($script_path['path']);
                }
                if (function_exists($call_func)) {
                    $call_func($this);
                }
            }
 
            if (!isset($GLOBALS['hook_cache'])) {
                $GLOBALS['hook_cache'] = array();
            }
            $GLOBALS['hook_cache'][$cache_key] = $hook_cache;
        }
 
        if (!$GLOBALS['egotec_setup']) {
            // Alle Verweise dieser Page sammeln
            if ($hook == 'update') {
                Ego_Queue::add(array($this, 'updateLinks'));
            }
 
            if ($GLOBALS['egotec_conf']['rewrite_engine'] == 'url') {
                if (
                    (
                        $hook == 'delete'
                        || $this->field['inactive']
                    )
                    && !$this->isWorkflowCopy()
                ) {
                    // URLs dieser Page archivieren
                    Ego_Queue::add(array($this, 'archiveUrls'));
                } else {
                    // URLs dieser Page aktualisieren
                    if ($hook == 'newchild') {
                        // Direkt ausführen, da die URLs direkt benötigt werden könnten
                        $this->updateUrls();
                    } else {
                        Ego_Queue::add(array($this, 'updateUrls'));
                    }
                }
            }
        }
    }
 
    function updateField($field, $matrix_flag = true, $asis = false, $silent = false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'updateField';
        }
 
        $this->replicate('updateField', $field, $matrix_flag, $asis, $silent);
 
        return $this->update(array('field' => $field), $matrix_flag, $asis, $silent);
    }
 
    function updateChildren($children) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'updateChildren';
        }
 
        $this->replicate('updateChildren', $children);
 
        return $this->update(array('children' => $children), true, true);
    }
 
    function updateParents($parents) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'updateParents';
        }
 
        $this->replicate('updateParents', $parents);
 
        return $this->update(array('parents' => $parents), true, true);
    }
 
    function updateExtra($extra, $matrix_flag = true, $asis = false, $silent = false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'updateExtra';
        }
 
        $this->replicate('updateExtra', $extra, $matrix_flag, $asis, $silent);
 
        return $this->update(array('extra' => $extra), $matrix_flag, $asis, $silent);
    }
 
    function updateRights($rights, $matrix_flag = true, $asis = false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'updateRights';
        }
 
        $this->replicate('updateRights', $rights, $matrix_flag, $asis);
 
        return $this->update(array('rights' => $rights), $matrix_flag, $asis);
    }
 
    function update($param = array(), $matrix_flag = true, $asis = false, $silent = false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'update';
        }
 
        if (empty($param)) {
            // Aktuelle Daten speichern
            $reload = $this->_update(array(
                'field' => $this->field,
                'extra' => $this->extra,
                'rights' => array(
                    'rights' => $this->getRightsArray(),
                    'users' => $this->getUsersArray()
                )
            ), $matrix_flag, $asis, $silent);
        } else {
            $reload = $this->_update($param, $matrix_flag, $asis, $silent);
        }
        if($this->field['deleted'] == "1") {
            $this->hookUpdate("delete");
            $this->message.= $GLOBALS['auth']->translate('Die Seite wurde gelöscht.');
        }
 
        $this->replicate('update', $param, $matrix_flag, $asis, $silent);
 
        return $reload;
    }
 
    public function updateIndex($search=null, $queue=true, $recursive=true) {
        if (
            // Zwischenspeicherungen aktualisieren nicht den Suchindex
            $this->archiveOnly
            // Erfolgt der Aufruf über den Liveabgleich und ist die "ewige" Cache aktiv, wird kein Suchindex aktualisiert
            || ($_SERVER['HTTP_X_SOAP_CALL'] == 'Replication' && $this->getSite()->getCache()->getEternal())
            || !empty($GLOBALS['__skip_update_index'])
        ) {
            return;
        }
 
        // Bei einer rekursiven Suchindex Aktualisierung sicherstellen, dass die selben Seiten nicht mehrfach aktualisiert werden
        if (isset($GLOBALS['__page_update_index_stack']) && in_array($this->getIdentity(), $GLOBALS['__page_update_index_stack'])) {
            return;
        }
        if (!isset($GLOBALS['__page_update_index_stack'])) {
            $GLOBALS['__page_update_index_stack'] = [];
        }
        $GLOBALS['__page_update_index_stack'][] = $this->getIdentity();
 
        if (!$search) {
            require_once('base/Ego_Search_Factory.php');
            try {
                $search = Ego_Search_Factory::start($this->_site->pageTable.$this->getTableSuffix(), ['throw_exception' => true]);
            } catch (Exception $e) {
                // Ist die Suche nicht erreichbar, darf es hier zu keinem Abbruch kommen
                Ego_Action::add(Ego_Action::PAGE_UPDATE_INDEX, [
                    'identity' => $this->getIdentity(),
                    'recursive' => $recursive
                ], $e);
                return;
            }
        }
 
        // Relevanz der Felder beachten
        if ($queue) {
            Ego_Queue::add(array($search, 'update'), array($this->field['id'], $this, $this->_site->getSearchCount($this->extra['search_weight']), $recursive));
        } else {
            // sofort ausführen
            $search->update($this->field['id'], $this, $this->_site->getSearchCount($this->extra['search_weight']), $recursive);
        }
    }
 
    public function convertImages($reset = false) {
        $convert_type = '';
 
        // Die relevanten Mandanten für die Einstellungen ermitteln
        $sites = [];
        if ($this->_site->site['type'] == 'media') {
            $convert_type = 'multimedia';
 
            foreach (Ego_System::getAllSites('', '', false, 'content') as $site) {
                if (
                    $site->site['media'] == $this->_site->name
                    && !empty($site->admin['image']['convert'])
                ) {
                    $sites[] = $site;
                }
            }
        } elseif (
            $this->_site->site['type'] == 'content'
            && !empty($this->_site->admin['mediapool']['active'])
            && !empty($this->_site->admin['image']['convert'])
        ) {
            $convert_type = 'mediapool';
 
            $sites[] = $this->_site;
        }
 
        // Liste aller bereits durchgeführten Umwandlungen
        $converted = [];
 
        foreach ($sites as $site) {
            if (
                (
                    $convert_type == 'multimedia'
                    && $this->field['type'] == 'multimedia/image'
                )
                || $convert_type == 'mediapool'
            ) {
                require_once 'base/Ego_Output.php';
 
                foreach (explode(',', $site->admin['image']['convert']) as $format) {
                    if (!in_array($format, $converted)) {
                        switch ($convert_type) {
                            // Multimedia
                            case 'multimedia':
                                if (
                                    !empty($this->field['extra']['convert_ignore'])
                                    && in_array($format, explode(',', $this->field['extra']['convert_ignore']))
                                ) {
                                    // Umwandlung ignorieren
                                    continue 2;
                                }
 
                                $output = new Ego_Output($this);
                                $output->convertImage($format, $reset);
                                break;
 
                            // Mediapool
                            case 'mediapool':
                                $mediapool = $this->getMediapool();
                                foreach ($mediapool->getDirs() as $dir) {
                                    foreach ($mediapool->list($dir) as $item) {
                                        if (
                                            $item['isImage']
                                            && !empty($item['convertIgnore'])
                                            && in_array($format, $item['convertIgnore'])
                                        ) {
                                            // Umwandlung ignorieren
                                            continue 4;
                                        }
                                    }
 
                                    $output = new Ego_Output($this, $item['name'], $dir);
                                    $output->convertImage($format, $reset);
                                }
                        }
 
                        $converted[] = $format;
                    }
                }
            }
        }
    }
 
    public function clearConvertedImages() {
        Ego_System::deldir($GLOBALS['egotec_conf']['var_dir']
            . 'converted/'
            . $this->_site->name . '/'
            . $this->_site->language . '/'
            . $this->field['id']);
    }
 
    function getChildren($query=array(), $param=array()) {
        $page_table = $this->_site->name.'_'.($param['lang']?$param['lang']:$this->_site->language);
        $children_table = $page_table.'_children';
        $query['table'] = $children_table;
 
        $query = $this->buildChildrenOrder($query, $param);
 
        $query['where'] = (isset($query['where'])?'('.$query['where'].') AND ':'').
            $children_table.'.page_id='.$this->field['id'].' AND '.$page_table.'.id='.$children_table.'.child';
        return $this->_site->getPages($query, $param);
    }
 
    public function buildChildrenOrder($query=array(), $param=array()) {
        $page_table = $this->_site->name.'_'.($param['lang']?$param['lang']:$this->_site->language);
        $children_table = $page_table.'_children';
        $order = trim(isset($query['order'])?$query['order']:$this->field['children_order']);
 
        if ($order[strlen($order) -1]=='R') {
            // r steht für reverse
            $param['reverse'] = !$param['reverse'];
            $order = substr($order, 0, strlen($order) -1);
        }
        switch ($order) {
            case 'title':
                $query['order'] = $page_table.'.title '.($param['reverse']?'desc':'asc');
                break;
            case 'name':
                $query['order'] = $page_table.'.name '.($param['reverse']?'desc':'asc');
                break;
            case 'a_date':
                $query['order'] = $page_table.'.a_date '.($param['reverse']?'desc':'asc');
                break;
            case 'c_date':
                $query['order'] = $page_table.'.c_date '.($param['reverse']?'desc':'asc');
                break;
            case 'release_from':
                $query['order'] = $page_table.'.release_from '.($param['reverse']?'desc':'asc');
                break;
            case 'release_until':
                $query['order'] = $page_table.'.release_until '.($param['reverse']?'desc':'asc');
                break;
            case 'asc':
                $query['order'] = $page_table.'.order_field '.($param['reverse']?'desc':'asc');
                break;
            case 'desc':
                $query['order'] = $page_table.'.order_field '.($param['reverse']?'asc':'desc');
                break;
            case 'type':
                $query['order'] = $page_table.'.type '.($param['reverse']?'desc':'asc').','.$page_table.'.name '.($param['reverse']?'desc':'asc');
                break;
            case 'none':
                unset($query['order']);
                break;
            case 'children':
                $query['order'] = $children_table.'.idx '.($param['reverse']?'desc':'asc');
                if (!isset($query['fields2'])) {
                    $query['fields2'] = [];
                } elseif (is_string($query['fields2'])) {
                    $query['fields2'] = [$query['fields2']];
                }
                $query['fields2'][] = $children_table.'.idx';
        }
        if ($query['order'] && $query['order']!='id') { // Um die rückwärts gerichtete Sortierung korrekt zu bekommen, muss immer noch nach der id sortiert werden.
            $query['order'].= ','.$page_table.'.id '.($param['reverse']?'desc':'asc');
        }
 
        return $query;
    }
 
    public function hasChildren($query = array(), $param = array()) {
        if (isset($this->field['has_children'])) {
            return !empty($this->field['has_children']);
        }
        $children = $this->getChildren($query, $param);
        while ($children->nextPage()) {
            return true;
        }
        return false;
    }
 
    function getParents($query=array(), $param=array()) {
        $page_table = $this->_site->name.'_'.($param['lang']?$param['lang']:$this->_site->language);
        $children_table = $page_table.'_children';
        $query['table'] = $children_table;
        $query['where'] = (isset($query['where'])?'('.$query['where'].') AND ':'').
            $children_table.'.child='.$this->field['id'].' AND '.$page_table.'.id='.$children_table.'.page_id';
 
        // Die Hauptkategorie ist das erste Elter (nur wenn nicht bereits explizit sortiert wird)
        if (!empty($this->extra['main_category']) && !isset($query['order'])) {
            $field2 = "CASE WHEN {$page_table}.id = {$this->extra['main_category']} THEN 1 ELSE 0 END AS main_category";
            if (!isset($query['fields2'])) {
                $query['fields2'] = [];
            }
            $query['fields2'][] = $field2;
            $query['order'] = "main_category DESC, {$page_table}.id ASC";
        }
 
        return $this->_site->getPages($query, $param);
    }
 
    function getAncestors($query=array(), $param=array()) {
        if ($this->field['deleted']) {
            $param = array_merge($param, array('deleted' => -1));
        }
        $ancestors_ids = $this->_getAncestorsIds($this, $param['children_query'], $param['children_param']);
        if ($param['id_list']) {
            return $ancestors_ids;
        }
        if ($ancestors_ids) {
            $ancestors_ids = array_reverse($ancestors_ids);
            $query['where'] = (isset($query['where'])?'('.$query['where'].') AND ':'').
                'id IN ('.join(',', $ancestors_ids).')';
            $query['proposed_order'] = array(
                'field' => 'id',
                'values' => $ancestors_ids
            );
            return $this->_site->getPages($query, $param);
        } else {
            return new Page_Iterator();
        }
    }
 
    function getDescendants($query=array(), $param=array()) {
        $lang = $param['lang']?$param['lang']:$this->_site->language;
        $page_table = $this->_site->name.'_'.$lang;
        if (!$param['children_query']) {
            $param['children_query']['fields'] = 'id';
        }
        $param['children_query']['order'] = '';
        $param['children_query']['hash'] = $this->field['id'].md5(serialize($param['children_query']));
        $param['children_param']['has_children'] = 1;
        $param['children_param']['no_cache'] = 1;
 
        $cache = $this->_site->getCache();
        $cache_key = '_desc_'.$this->field['id'].'_'.
            ($GLOBALS['auth'] ? $GLOBALS['auth']->getId() : 'guest').'_'.
            md5(serialize($param['children_query']).serialize($param['children_param'])).'_'.
            md5(serialize($this->_site->getHash()));
        $descendants_ids = $cache->get($cache_key);
        if ($descendants_ids === null) {
            $descendants_ids = array();
            $this->_getDescendantsIds($this, $param['children_query'], $param['children_param'], $descendants_ids);
            if ($param['with_root']) {
                $descendants_ids[] = $this->field['id'];
            }
            $cache->set($cache_key, $descendants_ids);
        }
        if ($param['return_ids']) {
            return $descendants_ids;
        }
        if ($descendants_ids) {
            $query['where'] = (isset($query['where'])?
                '('.$query['where'].') and ':
                '');
            // Oracle verträgt max. 1000 Elemente pro Liste
            $idgroups = array();
            foreach (array_chunk($descendants_ids, 999) as $ids)
            {
                // IDs splitten in 999-Häppchen
                $idgroups[] = $page_table.'.id in ('.implode(',', $ids).')';
            }
            $query['where'] .= '('.implode(' or ', $idgroups).')';
 
            //$page_table.'.id in ('.join(',', $descendants_ids).')';
            return $this->_site->getPages($query, $param);
        } else {
            return new Page_Iterator();
        }
    }
 
    function getSiblings($query=array(), $param=array(), $proposed_path=array()) {
        assert(
            (!isset($query['limit']) && isset($param['next']))
            || (isset($query['limit']) && !isset($param['next']))
            || (!isset($query['limit']) && !isset($param['next']))
        );
 
        $parents_query = $param['parents_query']?$param['parents_query']:array();
        if ($proposed_path) {
            $parents_query2 = $parents_query;
            $parents_query2['where'] = ($parents_query2['where']?$parents_query2['where'].' AND ':'').'id IN ('.join(',', $proposed_path).')';
            $parents = $this->getParents($parents_query2, array(
                'auth_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ));
            $parent = $parents->nextPage();
        }
        if (!$parent) {
            $parent = $this->getParents($parents_query, array(
                'auth_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ))->nextPage(); /* @var $parent Page */
        }
        if ($parent) {
            if ($param['without_self']) {
                $query['where'] .= (isset($query['where']) ? ' AND ' : '') . 'id != :self_id';
                $query['bind']['self_id'] = $this->field['id'];
            }
 
            $siblings = $parent->getChildren($query, $param);
            if ($param['next']) { // Nur die Geschwister ab der aktuellen Seite anzeigen.
                $siblings->setHaltId($this->field['id']);
            }
        }
        if ($siblings) {
            return $siblings;
        } else {
            return new Page_Iterator();
        }
    }
 
    function getLanguagePage($lang, $param = array()) {
        $site = clone $this->_site; /* @var $site Site */
        try {
            $site->setLanguage($lang);
        } catch (Site_Exception $e) {
            if ($e->getCode() == Site_Exception::LANG_DOESNT_EXIST) {
                return null;
            }
        }
        return $site->getPage($this->field['id'], $param);
    }
 
    function createLanguagePage($lang, $param = array()) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'createLanguagePage';
        }
 
        if (!in_array($lang, $this->_site->getLanguages())) {
            throw new Site_Exception('Die Sprache existiert nicht', Site_Exception::LANG_DOESNT_EXIST);
        }
 
        // Parameter um die Seite in jedem Fall zu erhalten
        $l_param = array(
            'auth_or' => '1=1',
            'deleted_or' => '1=1',
            'inactive' => true,
            'only_active' => false
        );
 
        if ($l_page = $this->getLanguagePage($lang, $l_param)) { // Übersetzte Seite existiert bereits, diese aktualisieren
            $field = is_array($param['field'])? $param['field']:$this->field;
            $extra = is_array($param['extra'])? $param['extra']:$this->extra;
 
            // Keine Workflow Historie übernehmen
            unset($extra['history']);
 
            $l_page->update(
                array(
                    'field' => $field,
                    'extra' => $extra
                )
            );
            return $l_page;
        } else {
            // Felder und Extra vorbereiten
            $field = is_array($param['field'])? $param['field']:$this->field;
            $field['id'] = $this->field['id'];
 
            $extra = is_array($param['extra'])? $param['extra']:$this->extra;
 
            // Keine Workflow Historie übernehmen
            unset($extra['history']);
 
            // Elternseite ermitteln
            $parents = $this->getParents(array(), $l_param);
 
            $parent = $parents->nextPage();
 
            // Übersetzte Elternseite ermitteln
            $l_parent = $parent->getLanguagePage($lang, $l_param);
 
            if (!$l_parent) { // Übersetzte Elternseite existiert nicht, alle benötigten Vorfahren anlegen
                $path = $this->getPath(false, $GLOBALS['current_path'], false);
 
                // Ab der übersetzten Startseite alle Vorfahren durchgehen
                $_parent = $this->_site->getRoot()->getLanguagePage($lang, $l_param);
 
                foreach ($path as $pid) {
                    // Übersetzten Vorfahren ermitteln
                    $p = $this->_site->getPage($pid, $l_param);
                    $lp = $p->getLanguagePage($lang, $l_param);
 
                    if (!$lp) { // Übersetzter Vorfahre existiert nicht, eine inaktive Sprachkopie anlegen
                        $copied_field = $p->field;
                        $copied_field['inactive'] = self::INACTIVE_FLAG;
 
                        $copied_extra = $p->extra;
                        $lp = $_parent->newChild($copied_field, $copied_extra);
                    } elseif ($lp->field['deleted']) {
                        // Übersetzter Vorfahre wurde gelöscht, Seite wiederherstellen
                        $restored_field = $p->field;
 
                        unset($restored_field['deleted']);
                        $restored_field['inactive'] = self::INACTIVE_FLAG; // Sprachkopie deaktivieren
 
                        $lp->updateField($restored_field);
                    }
 
                    // Nächste Elternseite ist die aktuelle übersetzte Seite
                    $_parent = $lp;
                }
 
                // Alle Vorfahren wurden angelegt, jetzt die erwünschte übersetzte Seite anlegen
                $l_child =  $_parent->newChild($field, $extra);
            } else { // Übersetzte Elternseite existiert, übersetzte Seite anlegen
                if ($l_parent->field['deleted']) {
                    // Übersetzter Vorfahre wurde gelöscht, Seite wiederherstellen
                    $restored_field = $l_parent->field;
 
                    unset($restored_field['deleted']);
                    $restored_field['inactive'] = self::INACTIVE_FLAG; // Sprachkopie deaktivieren
 
                    $l_parent->updateField($restored_field);
                }
 
                $l_child =  $l_parent->newChild($field, $extra);
            }
 
            // Mediapool kopieren
            $this->getMediapool()->copy($l_child);
            $l_child->getMediapool()->import(true);
 
            $this->replicate('createLanguagePage', $lang, $param);
 
            return $l_child;
        }
    }
 
    public function getKeywords($language = '', $own_keywords = false) {
        // Sprache muss gesetzt sein
        if ($language == '') {
            $language = $this->_site->language;
        }
 
        // Die Keyword-Tabelle ermitteln:
        // Das Schlagwortregister eines anderen Mandanten verwenden
        // (kann im Adminbereich pro Mandant eingestellt werden)
        if ($this->_site->admin['keywords']['site'] &&
            $this->_site->admin['keywords']['site'] != $this->_site->name
        ) {
            $keyword_table = $this->_site->admin['keywords']['site'].'_'.$language.'_keywords';
        } else {
            $keyword_table = $this->_site->name.'_'.$language.'_keywords';
        }
 
        // In der Relationen-Tabelle befinden sich die Zuweisungen,
        // also welches Schlagwort zu welcher Seite gehört
        $relation_table = $this->_site->name.'_keywords_rel';
 
        // Suche durchführen
        // Achtung! Diese Suche findet nur die Zuweisungen,
        // welche über den Pool verlinkt sind.
        // Nicht die eigenen Schlagworte, die in der Seite eingetragen wurden
        $db = new_db_connection();
 
        if (!$db->tableExists($keyword_table)) {
            return '';
        }
 
        $db->select(array(
            "fields"        => "*",
            "table"         => "$keyword_table INNER JOIN $relation_table ON $keyword_table.id = $relation_table.keyword_id",
            "where"         => 'page_id = '.$this->field['id']
        ));
 
        // Alle Keywords sammeln
        $keywords = array();
 
        // zunächst die Zuweisungen aus dem Pool
        $keywords_list = explode(',', $this->extra['keywords_list']);
        while ($result = $db->next()) {
            if (in_array($result['id'], $keywords_list)) {
                array_push($keywords,$result['word']);
            }
        }
 
        // die eigenen Keywords werden zusätzlich ins Extra-Feld kommasepariert gespeichert und hier auch ausgelesen
        if ($own_keywords && $this->extra['keywords_list_own']) {
            $tmp = explode(',', $this->extra['keywords_list_own']);
            $keywords = array_merge($keywords, $tmp);
        }
 
        // Die Keyword-Liste kommasepariert ausgeben
        $keywords = implode(',', $keywords);
        return trim($keywords, ',');
    }
 
    function addKeyword($word, $add_to_pool = false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'addKeyword';
        }
 
        // Whitespaces entfernen und Wort prüfen
        $word = trim($word);
        if ($word == '') {
            return false;
        }
 
        /*
         * Das Schlagwortregister kann auch aus einem andreen Mandanten verwendet werden
         * Achtung! Wenn z.B. in einem deutschen Page-Objekt ein Keywords hinzugefügt wird,
         * dieser Mandant aber nicht in dieser Sprache existiert,
         * dann wird kein Schlagwort erstellt.
         */
        if ($this->_site->admin['keywords']['site'] && $this->_site->admin['keywords']['site'] != $this->_site->name) {
            // Existenz der Sprache prüfen
            $keywordSite = new Site($this->_site->admin['keywords']['site'],$this->_site->language);
        } else {
            $keywordSite = $this->_site;
        }
 
        $k_db = new_db_connection();
        $k_db->select(array(
            'table'     => $keywordSite->pageTable.'_keywords',
            'where'     => 'LOWER(word)=:word',
            'bind'      => array('word' => strtolower($word))
        ));
 
        if($k_db->next()) {
            $maxid = $k_db->Record['id'];
        } else {
            // Die nächst höchste ID herausfinden von allen verfügbaren Sprachen des Mandanten
            $max = 0;
            foreach($keywordSite->getLanguages() as $sprache) {
                $u_db = new_db_connection();
                $u_db->select(array(
                    'fields' => 'id',
                    'table'  => $keywordSite->name.'_'.$sprache.'_keywords',
                    'order'  => 'id DESC',
                    'limit'  => '1'
                ));
 
                $maxentry = $u_db->next();
                if((int)$maxentry['id'] > $max) {
                    $max = (int)$maxentry['id'];
                }
            }
            $maxid = $max+1; // Neue ID ist höchste ID + 1
 
            $k_db->insert(array(
                    'table'     => $keywordSite->pageTable.'_keywords',
                    'set'       => array(
                        'id'            => $maxid,
                        'word'          => $word,
                        'c_date'        => date('Y-m-d H:i:s'),
                        'main'          => 1, // Neues Wort ist immer der Hauptsprachbegriff
                        'not_in_list'   => ($add_to_pool) ? 0 : 1 // Im gesamten Schlagwortregister aufnehmen oder nicht
                    ))
            );
        }
 
        $db2 = new_db_connection();
        $db2->select(array(
            'table'     => $keywordSite->name.'_keywords_rel',
            'where'     => "page_id = '".$this->field['id']."' AND keyword_id = '".$maxid."'",
            'order'     => 'page_id',
            'limit'     => 1
        ));
        if ($db2->next()) {
            return true;    // alles ok, Schlagwort ist bereits zugewiesen
        }
 
        if ($k_db->insert(array(
            'table'     => $keywordSite->name.'_keywords_rel',
            'set'       => array(
                'page_id'       => $this->field['id'],
                'keyword_id'    => $maxid,
                'c_date'        => date('Y-m-d H:i:s')
            )))) { // Abwärtskompatibilität Schlagworte auch in die Extra-Felder "keywords_list" und "keywords_list_own" schreiben
            // Alle zugewiesenden Schlagwort-Ids auslesen
            $k_db->select(array(
                'table'     => $keywordSite->name.'_keywords_rel',
                'where'     => "page_id = '".$this->field['id']."'"
            ));
            $entries = array();
            while ($entry = $k_db->next()) {
                $entries[] = $entry['id'];
            }
 
            // Alle Schlagworte auslesen
            $k_db->select(array(
                'table'     => $keywordSite->pageTable.'_keywords',
                'where'     => "id IN ('".implode("','", $entries)."')"
            ));
 
            $keywords_list = array();
            $keywords_list_own = array();
            while ($entry = $k_db->next()) {
 
                if ($entry['not_in_list'] == "1") {
                    $keywords_list_own[] = $entry['word'];
                } else {
                    $keywords_list[] = $entry['id'];
                }
            }
 
            // Schlagworte bzw. SchlagwortIDs kommasepariert ins extra-Feld
            if ($keywords_list || $keywords_list_own) {
                $this->extra['keywords_list'] = implode(",",$keywords_list);
                $this->extra['keywords_list_own'] = implode(",",$keywords_list_own);
                $this->updateExtra($this->extra,true);
            }
 
            $this->replicate('addKeyword', $word);
 
            return true;
        } else {
            return false;
        }
    }
 
    function getUrl($param = array()) {
        if (($this->extra['image_type'] || $param['pool']) && !$param['download'] && !$param['thumbnail']) { // Multimediaendung setzen.
            if (!$param['no_suffix'] && $this->extra['image_type']) {
                $param['suffix'] = $this->extra['image_type'];
            }
            unset($param['no_suffix']);
 
            /* Bild URLs müssen immer width und height Parameter beinhalten.
             * Wird nur width oder nur height übergeben, dann muss der Gegenwert
             * relativ berechnet werden (Skalierung).
             * Wird keiner der Parameter übergeben, dann werden die Originalwerte
             * verwendet (origImgWidth und origImgHeight).
             * Werden beide Parameter übergeben, dann werden diese verwendet.
             * Wird ein ungültiger Wert übergeben, dann wird der Parameter aus der URL entfernt.
             * Die URL Auflösung skaliert automatisch,
             * wenn nur width oder nur height in der URL vorkommt.*/
            $param = $this->addImageParams($param);
        }
        if (!$param['lang'] || $param['lang'] == $this->_site->language) {
            // Wird die URL für die aktuelle Seite angefordert, ist das Page Objekt bereits bekannt
            return $this->_site->getPageUrl($this->field['id'], $param, $this);
        }
        return $this->_site->getPageUrl($this->field['id'], $param);
    }
 
    public function getFrontendUrl($param = array()) {
        $now = date('Y-m-d H:i:s');
        if (
            $this->field['inactive'] > 0
            || ($this->field['release_from'] != '0000-00-00 00:00:00' && $this->field['release_from'] > $now)
            || ($this->field['release_until'] != '0000-00-00 00:00:00' && $this->field['release_until'] < $now)
            || $this->isWorkflowCopy()
            || $this->isReleaseCopy()
        ) {
            return '';
        }
        $param['get_frontend_url'] = true;
        return $this->getUrl($param);
    }
 
    public function getLiveUrl($param = array()) {
        if (((int) $this->field['nav_hide']&2) == 2) {
            // Es gibt keine Liveserver URLs für Seiten, die nicht auf dem Liveserver existieren dürfen
            return '';
        }
 
        // Immer eine absolute URL erzeugen
        $param['return_absolute'] = true;
 
        if (!$GLOBALS['egotec_conf']['liveserver']) {
            // URL vom (ersten) Liveserver erzeugen
            $clusters = Ego_System::getCluster();
            array_walk($clusters, function (&$value) {
                $value = $value['url'];
            });
            $liveservers = array_values(array_filter(array_merge([$this->_site->admin['live']['location']], $clusters)));
 
            if (!empty($liveservers)) {
                // Liveserver URL setzen
                $live = $this->_site->admin['live'];
                $live['location'] = $liveservers[0];
 
                require_once('soap/Ego_SOAP.php');
                $soap = new Ego_SOAP($live, 1);
                try {
                    return $soap->soapCall('pageGetUrl', [
                        'site' => $this->_site->name,
                        'lang' => $this->_site->language,
                        'id' => $this->field['id'],
                        'param' => soap_var($param)
                    ]);
                } catch (Exception $e) {
                    return '';
                }
            }
        }
 
        // URL von diesem Server erzeugen
        return $this->getFrontendUrl($param);
    }
 
    public function getCloneUrl() {
        return 'index.php?' . http_build_query(array(
                'id' => $this->field['id'],
                'site' => $this->_site->name,
                'lang' => $this->_site->language
            ));
    }
 
    public function getCloneOriginal() {
        if ($this->isClone()) {
            $param = array(
                'auth_or' => '1=1',
                'deleted_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            );
            if (is_numeric($this->extra['clone_original'])) { // abwärtskompatibel
                $page = $this->_site->getPage($this->extra['clone_original'], $param);
            } else {
                $page = Ego_System::urltopage($this->extra['clone_original'], array(
                    'params' => array(
                        'param' => $param
                    )
                ));
            }
            return $page;
        }
        return null;
    }
 
    function lock($user_id='') {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'lock';
        }
 
        if (!$user_id) {
            $user_id = $GLOBALS['auth']->getId();
        }
        if (!$user_id) {
            // bei einem anonymen Benutzer wird eine Kombination aus remote_addr und user_agent gespeichert #93240
            $user_id = $GLOBALS['auth']->getAnonymousId();
        }
 
        $db = new_db_connection(array(
            'fields' => 'egotec_page_lock.*,egotec_user.*, egotec_page_lock.user_id AS lock_user_id',
            'table' => 'egotec_page_lock',
            'join' => 'egotec_user on egotec_page_lock.user_id=egotec_user.user_id',
            'where' => "(page_table='".$this->_site->pageTable."') AND (page=".$this->field['id'].")"
        ));
        if ($db->nextRecord()) {
            if  (
                $db->Record['stamp'] >= (time() - $GLOBALS['egotec_conf']['page_timeout'])
                && $db->Record['user_id'] != $user_id
            ) {
                $db->Record['extra'] = unserialize($db->Record['extra']);
                return $db->Record;
            } else {
                $db->update(array(
                    'table' => 'egotec_page_lock',
                    'set' => array(
                        'user_id' => $user_id,
                        'stamp' => time()
                    ),
                    'where' => "page_table = '{$this->_site->pageTable}' AND page = {$this->field['id']}"
                ));
                return false;
            }
        }
 
        try {
            @$db->insert(array(
                'table' => 'egotec_page_lock',
                'set' => array(
                    'page_table' => $this->_site->pageTable,
                    'page' => $this->field['id'],
                    'user_id' => $user_id,
                    'stamp' => time()
                ),
                'nobackup' => true
            ));
        } catch (Exception $e) {
            // ignorieren
        }
 
        $this->replicate('lock', $user_id);
 
        return false;
    }
 
    function unlock($user_id=false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'unlock';
        }
 
        $db = new_db_connection();
        if ($user_id === false) {
            $user_id = $GLOBALS['auth']->getId();
        }
        if (!$user_id) {
            // bei einem anonymen Benutzer wird eine Kombination aus remote_addr und user_agent gespeichert #93240
            $user_id = $GLOBALS['auth']->getAnonymousId();
        }
        $db->delete(array(
            'table' => 'egotec_page_lock',
            'where' => "
                (page_table='".$this->_site->pageTable."') AND
                (page=".$this->field['id'].") AND
                (user_id='$user_id')"
        ));
 
        $this->replicate('unlock', $user_id);
    }
 
    public function isLocked($exclude_self = true) {
        $where = 'page_table = :page_table AND page = :page AND stamp >= :stamp';
        $bind = array(
            'page_table' => $this->_site->pageTable,
            'page' => $this->field['id'],
            'stamp' => time() - $GLOBALS['egotec_conf']['page_timeout']
        );
        if ($exclude_self) {
            $where .= ' AND user_id != :user_id';
            $bind['user_id'] = $GLOBALS['auth']->isNobody()
                ? $GLOBALS['auth']->getAnonymousId()
                : $GLOBALS['auth']->getId();
        }
        $db = new_db_connection(array(
            'table' => 'egotec_page_lock',
            'where' => $where,
            'bind' => $bind
        ));
        if ($db->nextRecord()) {
            try {
                $user = new User_SQL($db->Record['user_id']);
            } catch (User_Exception $e) {
                $user = null;
            }
            return array(
                'user' => $user,
                'stamp' => $db->Record['stamp']
            );
        }
        return array();
    }
 
    function getRightsArray($perm_type='', $no_null=false) {
        $db = $this->_getRights($perm_type);
        $a = array();
        while ($db->nextRecord()) {
            $a[$db->Record['perm']][] = array(
                'group_id'  => $db->Record['group_id'],
                'role_id'   => $db->Record['role_id']
            );
        }
        // Für alle Felder in denen kein IS NULL verwendet werden darf muss später ein *|* eingetragen werden
        if (!$perm_type) {
            $no_null_fields = explode(',', trim(Auth::NO_NULL_RIGHTS, ','));
            foreach ($no_null_fields as $f) {
                if (!$a[$f]) {
                    if ($f == 'live') {
                        // Das Veröffentlichen Recht ist standardmäßig immer root/Administrator
                        $a[$f][] = array(
                            'group_id' => $GLOBALS['egotec_conf']['superuser']['group'],
                            'role_id' => $GLOBALS['egotec_conf']['superuser']['role']
                        );
                    } elseif ($no_null) {
                        $a[$f][] = array(
                            'group_id' => '*',
                            'role_id' => '*'
                        );
                    } else {
                        $a[$f][] = array();
                    }
                }
            }
        }
        return $a;
    }
 
    public function getRights($perm_type='') {
        return $this->_getRights($perm_type);
    }
 
    function setRightsArray($rights) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'setRightsArray';
        }
 
        $db = new_db_connection();
        $db->begin();
        $table = $this->_site->pageTable.'_rights';
        $db->delete(array(
            'table' => $table,
            'where' => "page_id=".$this->field['id']
        ));
        $set = array(); // Doppelte Einträge vermeiden
        foreach ($rights as $perm => $perm_rights) {
            if ($perm_rights) { // $perm_rights könnte auch null sein.
                foreach ($perm_rights as $right) {
                    if ($right['group_id'] && $right['role_id']) { // Nur einfügen, wenn tatsächlich eine GroupID und RoleID angegeben ist.
                        $key = $this->field['id'].'.'.$perm.'.'.$right['group_id'].'.'.$right['role_id'];
                        if (!in_array($key, $set)) {
                            $db->insert(array(
                                'table' => $table,
                                'set' => array(
                                    'page_id'   => $this->field['id'],
                                    'perm'  => $perm,
                                    'group_id'  => $right['group_id'],
                                    'role_id'   => $right['role_id']
                                )
                            ));
                            $set[] = $key;
                        }
                    }
                }
            }
        }
        $db->commit();
 
        $this->replicate('setRightsArray', $rights);
    }
 
    function getUsersArray($perm_type='') {
        $db = $this->_getUsers($perm_type);
        $a = array();
        while ($db->nextRecord()) {
            $a[$db->Record['perm']][] = array(
                'user_id'   => $db->Record['user_id']
            );
        }
        return $a;
    }
 
    function setUsersArray($users) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'setUsersArray';
        }
 
        $db = new_db_connection();
        $table = $this->_site->pageTable.'_users';
        $db->delete(array(
            'table' => $table,
            'where' => "page_id=".$this->field['id']
        ));
        $set = array(); // Doppelte Einträge vermeiden
        foreach ($users as $perm => $perm_users) {
            if ($perm_users) { // $perm_users könnte auch null sein.
                foreach ($perm_users as $user) {
                    if ($user['user_id']) { // Nur einfügen, wenn tatsächlich eine UserID angegeben ist.
                        $key = $this->field['id'].'.'.$perm.'.'.$user['user_id'];
                        if (!in_array($key, $set)) {
                            $db->insert(array(
                                'table' => $table,
                                'set' => array(
                                    'page_id'   => $this->field['id'],
                                    'perm'  => $perm,
                                    'user_id'   => $user['user_id']
                                )
                            ));
                            $set[] = $key;
                        }
                    }
                }
            }
        }
 
        $this->replicate('setUsersArray', $users);
    }
 
    public function getSite() {
        return $this->_site;
    }
 
    public function getMediapool() {
        return new Mediapool($this);
    }
 
    public function hasParent($parent_id) {
        $db = new_db_connection(array(
            'table' => $this->_site->pageTable.'_children',
            'where' => 'page_id='.$parent_id.' AND child='.$this->field['id']
        ));
        return $db->nextRecord() !== null;
    }
 
    public function addParent($parent_id, $asis=false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'addParent';
        }
 
        $this->archiveOnly = false;
        if (!$this->_addParent($parent_id)) {
            return false;
        }
        $this->_updateField(array(), true, $asis, $asis); // Änderungsdatum aktualisieren und Cache löschen.
        $this->hookUpdate();
 
        $this->replicate('addParent', $parent_id, $asis);
 
        return true;
    }
 
    public function addChild($child_id='', $child_id2='') {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'addChild';
        }
 
        if (!$child_id) {
            $child_id = $child_id2;
        }
        $this->_site->getPage($child_id)->addParent($this->field['id']);
 
        $this->replicate('addChild', $child_id, $child_id2);
    }
 
    public function delParent($parent_id, $asis=false) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'delParent';
        }
 
        $this->archiveOnly = false;
        $this->_removeParent($parent_id);
        $this->_updateField(array(), true, $asis, $asis); // Änderungsdatum aktualisieren und Cache löschen.
        $this->hookUpdate();
 
        $this->replicate('delParent', $parent_id, $asis);
    }
 
    public function isWriteable(){
        if (!$this->hasRights(array('edit'))) {
            return false;
        } else if (
            $this->_site->admin['workflow']['enabled'] // Workflow ist aktiviert
            && $this->field['workflow'] // UND und für dieser Seite ist ein Workflow zugewiesen
            && !(int)$this->extra['original_id']    // UND bei der Site handelt es sich NICHT um eine Worflow-Kopie
            && !$this->hasRights('workflow') // UND der aktuelle User hat NICHT das Recht den Workflow zu ändern
        ) {
            return false;
        }
        return true;
    }
 
    public function isRoot() {
        return ($this->field['id'] == $this->_site->rootId);
    }
 
    public function getPath($with_root=true, $proposed_path=array(), $return_string=true, $query=array('fields' => 'id,name,url,inactive'), $param = array(), &$assorted = null) {
        $return_pages = $return_string == 2 && $return_string != 1;
        if ($return_pages) {
            /* Werden Page Objekte zurückgeliefert, dann diese immer mit allen Daten.
             * Ansonsten können Methoden wie update(), newChild(), usw. auf diesen Page Objekten Probleme machen. */
            unset($query['fields']);
        }
        if (!isset($param['inactive'])) {
            // Falls die Einstellung zu inaktiven Seiten nicht explizit übergeben wird, wird die des Site Objekts verwendet.
            $param['only_active'] = $this->_site->getOnlyActive();
            $param['inactive'] = !$param['only_active'];
        }
 
        $cache_key = 'path'.md5(serialize([$this->getIdentity(), $with_root, $proposed_path, $return_string, $query, $param]));
        $cache_entry = $this->_site->getCacheEntry($cache_key);
 
        if ($cache_entry === null) {
            if (
                !empty($this->extra['main_category'])
                && empty($proposed_path)
                && ($category = $this->_site->getPage($this->extra['main_category'], array_merge($param, array(
                    'auth_or' => '1=1'
                ))))
            ) {
                $proposed_path = $category->getPath(false, [], false);
                $proposed_path[] = $category->field['id'];
            }
 
            if ($this->field['id'] == $this->_site->rootId) {
                // Die Startseite hat keinen Pfad
                if ($with_root) {
                    // ...und gibt maximal sich selbst aus
                    if ($return_pages) {
                        $path = array($this);
                    } elseif ($return_string) {
                        if ($GLOBALS['egotec_conf']['meta_in_path']) {
                            $path = Ego_System::encode_path(empty($this->field['url'])?$this->field['name']:$this->field['url']).'/';
                        } else {
                            $path = Ego_System::encode_path($this->field['name']).'/';
                        }
                    } else {
                        $path = array($this->field['id']);
                    }
                } else {
                    $path = in_array($return_string, array(1, true), true) ? '' : array();
                }
            } else {
                if (
                    !$proposed_path && is_array($GLOBALS['current_path'])
                ) {
                    $proposed_path = $GLOBALS['current_path'];
                }
                $proposed_path[] = $this->field['id'];
                $ancestor_ids = array();
                $ancestor_order = false;
                $hidden_ancestor_ids = array();
                foreach (
                    $this->getAncestors(
                        array('fields' => 'id,nav_hide'),
                        array_merge(array(
                            'auth_or' => '1=1',
                            'inactive' => self::INACTIVE_FLAG,
                            'children_query' => array('where' => "type != '_keywords/entry'"),
                            'children_param' => array_merge(array('auth_or' => '1=1', 'inactive' => self::INACTIVE_FLAG), $param)
                        ), $param)
                    )
                as $page) { // Alle möglichen Pfade der aktuellen Seite.
                    if (!$GLOBALS['admin_area'] && $page->field['nav_hide']&1 == 1) {
                        $hidden_ancestor_ids[] = $page->field['id'];
                    } else {
                        $ancestor_ids[] = $page->field['id'];
                    }
                }
                if (!empty($hidden_ancestor_ids)) {
                    // Pfade im Frontend möglichst nur aus Seiten generieren, die in der Navigation erreichbar sind
                    $ancestor_ids = array_merge($ancestor_ids, $hidden_ancestor_ids);
                    if (!empty($ancestor_ids)) {
                        $ancestor_order = '(CASE id';
                        foreach ($ancestor_ids as $index => $ancestor_id) {
                            $ancestor_order .= ' WHEN ' . $ancestor_id . ' THEN ' . ($index + 1);
                        }
                        $ancestor_order .= ' ELSE ' . (sizeof($ancestor_ids) + 1) . ' END)';
                    }
                }
                $ancestor_ids[] = $this->field['id'];
                if ($ancestor_ids) {
                    $ancestor_where = ' AND id IN ('.join(',', $ancestor_ids).')';
                }
                $page = $this->_site->getRoot(array_merge(array('auth_or' => '1=1'), $param));
                if ($with_root) {
                    if ($return_pages) {
                        $path[] = $this->_site->getPage($this->_site->rootId, array_merge(array('auth_or' => '1=1'), $param));
                    } elseif ($return_string) {
                        if ($GLOBALS['egotec_conf']['meta_in_path']) {
                            $path = Ego_System::encode_path(empty($page->field['url'])?$page->field['name']:$page->field['url']).'/';
                        } else {
                            $path = Ego_System::encode_path($page->field['name']).'/';
                        }
                    } else {
                        $path[] = $this->_site->rootId;
                    }
                } else {
                    $path = in_array($return_string, array(1, true), true) ? '' : array();
                }
                while ($page->field['id']!=$this->field['id'] && $page) {
                    $proposed_id = array_shift($proposed_path);
                    if ($proposed_id==$page->field['id']) {
                        $proposed_id = array_shift($proposed_path);
                    }
                    if (in_array($proposed_id, $hidden_ancestor_ids)) {
                        $proposed_id = null;
                    }
                    if ($proposed_id && is_numeric($proposed_id)) {
                        $children = $page->getChildren(
                            array(
                                'fields'    => $query['fields'] ?? $this->_site->pageTable . '.*',
                                'where' => 'id=:id'.$ancestor_where,
                                'order' => $ancestor_order,
                                'bind' => array(
                                    'id' => $proposed_id
                                )
                            ), array_merge(array(
                                'auth_or'   => '1=1', 'inactive' => self::INACTIVE_FLAG
                            ), $param)
                        );
                        $child = $children->nextPage();
                    } else {
                        $child = false;
                    }
                    if (!$child) {
                        $children = $page->getChildren(
                            array(
                                'fields'    => $query['fields'] ?? $this->_site->pageTable . '.*',
                                'where' => '1=1 '.$ancestor_where,
                                'order' => $ancestor_order
                            ), array_merge(array(
                                'auth_or'   => '1=1', 'inactive' => self::INACTIVE_FLAG
                            ), $param)
                        );
                        $child = $children->nextPage();
                        if (!$child) {
                            break;
                        }
                    }
                    if ($child->field['id']==$this->field['id']) {
                        break;
                    }
                    if (
                        $child->field['inactive'] == self::ACTIVE_FLAG
                        || !empty($param['inactive']) // Falls inaktive Seiten im Pfad abgefragt werden
                    ) {
                        if ($return_pages) {
                            $path[] = $child;
                        } elseif ($return_string) {
                            if ($_SESSION['export']) {
                                $path.='-p-'.$child->field['id'].'/';
                            } else {
                                if ($GLOBALS['egotec_conf']['meta_in_path']) {
                                    $path.= Ego_System::encode_path(empty($child->field['url'])?$child->field['name']:$child->field['url']).'/';
                                } else {
                                    $path.= Ego_System::encode_path($child->field['name']).'/';
                                }
                            }
                        } else {
                            $path[] = $child->field['id'];
                        }
                    }
                    $page = $child;
 
                    // Prüfen, ob der Pfad wirklich eindeutig ist (keine Seite im Pfad hat in selber Ebene eine gleichnamige Seite)
                    if ($assorted === false) {
                        $siblings = $page->getSiblings(array(
                            'fields' => 'id,url,name',
                            'where' => '(url = :name1 OR name = :name2)',
                            'bind' => array(
                                'name1' => $child->field['name'],
                                'name2' => $child->field['name']
                            )
                        ), array_merge(array('auth_or' => '1=1'), $param));
                        if ($siblings->numRecords() > 1) {
                            $assorted = true;
                        }
                    }
                }
            }
 
            $this->_site->setCacheEntry($cache_key, [
                'path' => $return_pages ? array_map(function($page) {
                    // Pages in Identitäten umwandeln
                    return $page->getIdentity();
                }, $path) : $path,
                'assorted' => $assorted
            ]);
        } else {
            $path = $return_pages && is_array($cache_entry['path']) ? array_map(function($identity) use ($param) {
                // Identitäten in Pages umwandeln
                return self::isIdentity($identity) ? Page::byIdentity($identity, $param) : $identity;
            }, $cache_entry['path']) : $cache_entry['path'];
            $assorted = $cache_entry['assorted'];
        }
        return $path;
    }
 
    private function getPaths($with_root = false, $in_root = false, $area_domain = false) {
        $paths = array();
        $get_path = function($page, $path = array()) use (&$get_path, &$paths, $with_root, $in_root, $area_domain) {
            if (
                !$with_root
                && (
                    $page->field['id'] == $this->_site->rootId
                    || ($area_domain && $page->extra['area_domain'])
                )
            ) {
                array_pop($path);
                return $path;
            }
            $get_name = function($page) {
                $names = $page->getUrlNames();
                return array(
                    'name' => $names[0],
                    'id' => (int) $page->field['id']
                );
            };
            $index = 0;
            $original_path = $path;
            foreach ($page->getParents(array(), array(
                'auth_or' => '1=1',
                'deleted_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            )) as $parent) {
                // Alle Pfade dieser Seite aus dem Cache verwenden
                $cache_key = 'getPaths' . md5(serialize([$parent->field['id'], $with_root, $in_root, $area_domain]));
                $cached_paths = $this->_site->getCacheEntry($cache_key);
                if ($cached_paths !== null) {
                    $cached_path = array_pop($cached_paths);
 
                    if ($index == 0) {
                        if ($cached_path[sizeof($cached_path) - 1]['name'] === '') {
                            // Die Startseite im Pfad ist nur für Seiten direkt unterhalb der Startseite relevant
                            array_pop($cached_path);
                        }
                        array_unshift($cached_path, $get_name($parent));
                        $path = array_merge($path, $cached_path);
                    } elseif (!empty($cached_paths)) {
                        $paths = array_merge($paths, $cached_paths);
                    }
 
                    $index++;
                    continue;
                }
 
                if ($index++ == 0) {
                    // Erster Pfad
                    $path[] = $get_name($parent);
                    $path = $get_path($parent, $path);
                    if (empty($path) && $in_root && $parent->field['id'] == $this->_site->rootId) {
                        // Pfad direkt unter der Startseite aufnehmen
                        $path[] = array(
                            'name' => '',
                            'id' => $with_root ? (int) $parent->field['id'] : ''
                        );
                    }
                } else {
                    // Weitere Pfade
                    $tmp_path = $original_path;
                    $tmp_path[] = $get_name($parent);
                    $paths[] = $get_path($parent, $tmp_path);
                }
            }
            return $path;
        };
        $path = $get_path($this);
        if (!empty($path)) {
            $paths[] = $path;
        }
 
        // Alle Pfade im Cache speichern, um sie später wiederverwenden zu können
        if (sizeof($paths) > 0) {
            $cache_key = 'getPaths' . md5(serialize([$this->field['id'], $with_root, $in_root, $area_domain]));
            $this->_site->setCacheEntry($cache_key, $paths);
        }
 
        if (!empty($paths)) {
            $paths = array_reverse(array_map('array_reverse', $paths));
            $grouped_paths = array();
            foreach ($paths as $index => $path) {
                foreach ($path as $entry) {
                    foreach ($entry as $key => $value) {
                        $grouped_paths[$index][$key][] = $value;
                    }
                }
            }
            foreach ($grouped_paths as $index => $path) {
                foreach ($path as $key => $values) {
                    $grouped_paths[$index][$key] = implode($key == 'name' ? '/' : ',', $values);
                }
            }
            return $grouped_paths;
        }
        return $paths;
    }
 
    public function createPath($lang) {
        $parents = $this->getParents([], ['auth_or' => '1=1', 'deleted_or' => '1=1']);
 
        $root = $this->_site->getRoot();
        foreach ($parents as $parent) {
            $lang_parent = $parent->getLanguagePage($lang, ['auth_or' => '1=1', 'deleted_or' => '1=1']);
            if (!$lang_parent) { // Wenn die Elternseite nicht existiert, dann alle benötigten Vorfahren anlegen
                $_vorfahr = $parent->getPath(false, [], 2, [], ['auth_or' => '1=1', 'deleted_or' => '1=1', 'only_active' => false, 'inactive' => true]);
                $_vorfahr[] = $parent;
 
                $opa = $root->getLanguagePage($lang, ['auth_or' => '1=1', 'deleted_or' => '1=1', 'only_active' => false, 'inactive' => true]);
                foreach ($_vorfahr as $vorfahr) {
                    $vorfahr_field = $vorfahr->field;
                    unset($vorfahr_field['a_user']);
                    unset($vorfahr_field['a_date']);
                    $vorfahr_extra = $vorfahr->extra;
                    unset($vorfahr_extra['workflow_page']);
                    $vorfahr_field['inactive'] = 1; // Sprachkopien müssen immer inaktiv sein.
 
                    $vater = $vorfahr->getLanguagePage($lang, ['auth_or' => '1=1', 'deleted_or' => '1=1', 'only_active' => false, 'inactive' => true]);
 
                    if ($vater) {
                        if ($vater->field['deleted']) { // Falls die Sprachseite gelöscht ist, wird sie wiederhergestellt und bekommt die Inhalte kopiert.
                            $vater->update(['field' => $vorfahr_field, 'extra' => $vorfahr_extra]);
                        }
                    } else { // Seite ist nicht vorhanden und muss angelegt werden
                        // Keine Workflow Historie übernehmen
                        unset($vorfahr_extra['history']);
 
                        $vater = $opa->newChild($vorfahr_field, $vorfahr_extra);
                        // Rechte von der Original Sprachseite übernehmen
                        $vater->setRightsArray($vorfahr->getRightsArray());
                        $vater->setUsersArray($vorfahr->getUsersArray());
                    }
 
                    $opa = $vater;
                }
            } elseif ($lang_parent->field['deleted']) {
                // Elternseite wiederherstellen
                $lang_parent->undelete();
            }
        }
    }
 
    public function hasMultiParents(){
        return ((integer)$this->getParents(array(), array('auth_or'=>'1=1'))->numRecords())>1;
    }
 
    static function unserialize ($session_value) {
        $obj = @unserialize($session_value);
        if (get_class($obj) == '__PHP_Incomplete_Class') {
            $session_value = preg_replace('/^O:\d+:"Page.*?":/msi', 'O:4:"Page":', $session_value);
            $obj = @unserialize($session_value);
            if (get_class($obj) == '__PHP_Incomplete_Class') {
                return null;
            }
        }
        return $obj;
    }
 
    public function serialize (){
        return serialize($this);
    }
 
    public function __toString(){
        return get_class($this).'('.$this->getIdentity().')';
    }
 
    protected function _cleanEmptyContent(&$field) {
        if ($this->field['type']=="code") {
            return;
        }
 
        if ($field['content']) { // der neue Content
            $str = $field['content'];
        } else { // der alte Content
            $str = $this->field['content'];
        }
 
        if ($str != '') {
            if (Ego_System::isEmptyContent($str)) {
                $field['content'] = ''; // richtig leeren
            }
        }
    }
 
    public function cleanEmptyContent($asis=false, $silent=false) {
        $field = array();
        $field['content'] = $this->field['content'];
        $vorher = strlen($field['content']);
        $this->_cleanEmptyContent($field);
        $nachher = strlen($field['content']);
        if ($vorher != $nachher) {
            $param = array(
                'field' => $field
            );
            $this->update($param,array(),true, $asis, $silent);
            return true;
        }
        return false;
    }
 
    public function getMediaFilename($force_lang = false, $suffix = "") {
        $dir = $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/';
        $id = $this->field['id'].$suffix;
        $filename = $this->_site->language.'/'.$id;
 
        // Verzeichnis für die Sprache anlegen
        Ego_System::mkdir($dir.$this->_site->language);
 
        if (
            Ego_System::file_exists($dir.$filename) // Datei existiert in dieser Sprache
            || $force_lang // ID und Sprache muss ausgegeben werden
        ) {
            return $filename;
        } elseif (
            $this->_site->language != $this->_site->site['default_language']
            && Ego_System::file_exists($dir.$this->_site->site['default_language'].'/'.$id)
        ) {
            // Datei existiert aber in der Standard Sprache
            return $this->_site->site['default_language'].'/'.$id;
        }
 
        // Nur die ID ausgeben
        return $id;
    }
 
    public function addImageParams($param = array()) {
        $width = $param['width'];
        $height = $param['height'];
        $orig_width = $orig_height = null;
 
        // Die originale Breite/Höhe wird übergeben
        foreach (array('width', 'height') as $key) {
            if (isset($param['original_' . $key])) {
                $var = 'orig_' . $key;
                ${$var} = (int) $param['original_' . $key];
                unset($param['original_' . $key]);
            }
        }
 
        $use_clip = function($clip) use (&$orig_width, &$orig_height) {
            [$x1, $y1, $x2, $y2] = explode(',', $clip, 4);
            $orig_width = $x2 - $x1;
            $orig_height = $y2 - $y1;
        };
 
        if ($this->extra['image_type']) {
            // Multimedia
            if ($this->extra['mime_type'] == 'image/svg+xml') {
                return $param;
            }
 
            $orig_width = $this->extra['origImgWidth'];
            $orig_height = $this->extra['origImgHeight'];
            if (!empty($this->extra['edit']['clip'])) {
                $use_clip($this->extra['edit']['clip']);
            }
        } elseif (isset($param['pool'])) {
            // Mediapool
            $pool = $this->getMediapool()->get($param['pool'], $param['dir']);
            if (!empty($pool) && $pool['isImage'] && !in_array($pool['mime'], array('image/svg', 'image/svg+xml'))) {
                require_once 'base/Ego_Image.php';
                [$orig_width, $orig_height] = Ego_Image::getDimensions($pool['file']);
                if (!empty($pool['clip'])) {
                    $use_clip($pool['clip']);
                }
            } elseif (!$orig_width && !$orig_height) {
                return $param;
            }
        } else {
            return $param;
        }
 
        if (is_numeric($param['width'])) {
            if (
                is_numeric($orig_width)
                && is_numeric($orig_height)
                && !isset($param['height'])
            ) {
                $width = $param['width'];
                $height = ceil($orig_height * ($param['width'] / $orig_width));
            }
        } elseif (is_numeric($orig_width) && !isset($param['height'])) {
            $width = $orig_width;
        }
        if (is_numeric($param['height'])) {
            if (
                is_numeric($orig_height)
                && is_numeric($orig_width)
                && !isset($param['width'])
            ) {
                $width = ceil($orig_width * ($param['height'] / $orig_height));
                $height = $param['height'];
            }
        } elseif (is_numeric($orig_height) && !isset($param['width'])) {
            $height = $orig_height;
        }
        if (is_numeric($width)) {
            $param['width'] = $width;
        } else {
            unset($param['width']);
        }
        if (is_numeric($height)) {
            $param['height'] = $height;
        } else {
            unset($param['height']);
        }
        return $param;
    }
 
    public function hasLanguageFile($lang) {
        $dir = $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/';
        $filename = $lang.'/'.$this->field['id'];
 
        return file_exists($dir.$filename);
    }
 
    public function destroyFile(){
        $dir = $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/';
        $filename = $this->_site->language.'/'.$this->field['id'];
 
        if (file_exists($dir.$filename)) {
            unlink($dir.$filename);
        }
 
        $mediafiles = glob($dir.$filename.'_*');
        if (is_array($mediafiles)) {
            foreach ($mediafiles as $mediafile) {
                unlink($mediafile);
            }
        }
 
        // Die Seite existiert ohne Sprache und die aktuelle Sprache ist die Standard Sprache
        if ($this->_site->language == $this->_site->site['default_language']) {
            $filename = $this->field['id'];
 
            if (file_exists($dir.$filename)) {
                unlink($dir.$filename);
            }
 
            $mediafiles = glob($dir.$filename.'_*');
            if (is_array($mediafiles)) {
                foreach ($mediafiles as $mediafile) {
                    unlink($mediafile);
                }
            }
        }
    }
 
    public function getProtocol($site = null) {
        if (!$site) {
            $site = $GLOBALS['site'];
        }
        return 'http'.(
            ($_SERVER['HTTPS'] == 'on'
                && $site
                && $site->name == $this->_site->name
                && $site->language == $this->_site->language)
            || !empty($this->extra['https']) ? 's' : ''
            ).'://';
    }
 
    public function getInformationLocked() {
        $params = array();
        $params['tpl_name'] = 'information_locked.html';
        if ($this->field['type'] == 'multimedia/image') {
            $params['tpl_name'] = 'information_locked_image.html';
        }
        $file_name = $GLOBALS['egotec_conf']['site_dir'].$this->_site->name.'/'.$this->field['type'].'/admin/navigation.ini';
        if (!file_exists($file_name)) {
            $file_name = $GLOBALS['egotec_conf']['site_dir'].$this->_site->name.'/admin/navigation.ini';
            if ($this->_site->globalAllowed() && !file_exists($file_name)) {
                $file_name = $GLOBALS['egotec_conf']['site_dir'].'_global/admin/navigation.ini';
            }
        }
        if (file_exists($file_name)) {
            $navigation = parse_ini_file($file_name, true);
            foreach ($navigation as $key => $value) {
                if (stripos($value['url'], 'info.php?') === 0) {
                    if (preg_match_all('/([^\?&=]+)=([^\?&=#]*)/', $value['url'], $matches)) {
                        foreach ($matches[0] as $index => $match) {
                            if ($matches[1][$index] != 'tpl_name') {
                                $params[$matches[1][$index]] = $matches[2][$index];
                            }
                        }
                    }
                    break;
                }
            }
        }
        $params['url'] = 'extra.php?'.http_build_query($params);
        return $params;
    }
 
    public function getContent($main_orient = false, $variant = '', $include_scripts = false) {
        $content = '';
        if ($variant != '') {
            // Block Variante global weiterreichen, damit alle Aufrufe im fetch() darauf zugreifen können
            $GLOBALS['_block_variant'] = $variant;
        }
        if ($this->isFrontendAdmin(false)) {
            if ($main_orient) {
                // Nur die Blöcke der Haupt-Orientierung
                $content = $this->getBlocks($this->mainOrient, $variant, $include_scripts);
            } elseif ($layout = $this->getLayout($GLOBALS['is_mobile'])) {
                require_once 'smarty/Ego_Smarty.php';
                $smarty = Ego_Smarty::createFrontend($this->_site, array(
                    'page' => $this
                ));
                $smarty->autoload_filters['output'] = array('frontend_edit');
 
                // Seiten spezifische Skripte einbinden
                if ($include_scripts) {
                    $include_script = function($file) use ($smarty) {
                        // Weitere Variablen im Skript verfügbar machen
                        $page = $this;
                        $site = $page->getSite();
                        $auth = $GLOBALS['auth'];
 
                        $length = strlen($needle = "/{$this->field['type']}/index.php");
                        if (substr($file, -$length) === $needle) {
                            // Nur das Seitentyp spezifische Skript mehrmals einbinden
                            require $file;
                        } else {
                            require_once $file;
                        }
                    };
                    foreach ($this->getScripts() as $file) {
                        $include_script($file);
                    }
                }
 
                $original_smarty = $GLOBALS['smarty'];
                $GLOBALS['smarty'] = $smarty;
                $content = $smarty->fetch($layout);
                $GLOBALS['smarty'] = $original_smarty;
            }
        }
        if ($content == '') {
            $content = $this->field['content'];
        }
        unset($GLOBALS['_block_variant']);
        return $content;
    }
 
    public function getLayout($mobile = false, $name = '', $suffix = '', &$script = '', $skip = array('module')) {
        // Layout Template ermitteln
        if (empty($suffix)) {
            $suffix = $_SERVER['REQUEST_SUFFIX'];
        }
        $suffix = $suffix != '.html' ? $suffix : '';
        $name = $name ? $name : $this->extra['_layout'];
        $cache_key = 'pageLayout'.md5(serialize(array($this->field['type'], $name, $mobile, $suffix, $skip)));
        $layout = $this->_site->getCacheEntry($cache_key);
 
        if ($layout === null) {
            $layout = '';
            $set_to_default = false;
 
            if ($name !== $this->conf['default_layout']) {
                // Prüfen, ob das Layout vom Seitentyp aus erlaubt ist
                $typeInfo = $this->getTypeInfo();
                if (isset($typeInfo['layouts']) && !in_array($name, explode(',', $typeInfo['layouts']))) {
                    $layout = $this->getLayout($mobile, $this->conf['default_layout'], '.html', $script, $skip);
                    $set_to_default = true;
                }
 
                // Prüfen, ob das Layout in der conf.json deaktiviert ist
                if (
                    !empty($this->conf['layouts'])
                    && isset($this->conf['layouts'][$name]['disabled'])
                    && $this->conf['layouts'][$name]['disabled']
                ) {
                    $layout = $this->getLayout($mobile, $this->conf['default_layout'], '.html', $script, $skip);
                    $set_to_default = true;
                }
            }
 
            if (!$set_to_default) {
                foreach (array('.tpl', '.html') as $file_suffix) {
                    if (!empty($name) && $name != 'default') {
                        if (
                            ($file = $this->_site->getSkinFile("{$this->field['type']}/layouts/{$name}{$suffix}{$file_suffix}", $skip))
                            || ($file = $this->_site->getSkinFile("layouts/{$name}{$suffix}{$file_suffix}", $skip))
                        ) {
                            $layout = $file;
                            break;
                        }
                    } else if (
                        ($file = $this->_site->getSkinFile("{$this->field['type']}/layout{$suffix}{$file_suffix}", $skip))
                        || ($file = $this->_site->getSkinFile("layout{$suffix}{$file_suffix}", $skip))
                    ) {
                        $layout = $file;
                        break;
                    }
                }
 
                if (empty($layout)) {
                    if ($suffix != '') {
                        $layout = $this->getLayout($mobile, $name, '.html', $script, $skip);
                    } elseif ($name != $this->conf['default_layout']) {
                        $layout = $this->getLayout($mobile, $this->conf['default_layout'], '.html', $script, $skip);
                    }
                }
            }
 
            $this->_site->setCacheEntry($cache_key, $layout);
        }
 
        // Layout Skript ermitteln
        $cache_key = 'pageLayoutScript'.md5(serialize(array($this->field['type'], $name, $mobile, $suffix, $skip)));
        $script = $this->_site->getCacheEntry($cache_key);
 
        if ($script === null) {
            $script = '';
 
            if (!empty($name) && $name != 'default') {
                if ($name == 'default') {
                    if (
                        ($file = $this->_site->getSiteFile("{$this->field['type']}/layout{$suffix}.php", $skip))
                        || ($file = $this->_site->getSiteFile("layout{$suffix}.php", $skip))
                    ) {
                        $script = $file;
                    }
                } elseif (
                    ($file = $this->_site->getSiteFile("{$this->field['type']}/layouts/{$name}{$suffix}.php", $skip))
                    || ($file = $this->_site->getSiteFile("layouts/{$name}{$suffix}.php", $skip))
                ) {
                    $script = $file;
                }
            }
            if (
                empty($script)
                && (
                    ($file = $this->_site->getSiteFile("{$this->field['type']}/layout{$suffix}.php", $skip))
                    || ($file = $this->_site->getSiteFile("layout{$suffix}.php", $skip))
                )
            ) {
                $script = $file;
            }
            $this->_site->setCacheEntry($cache_key, $script);
        }
 
        return $layout;
    }
 
    public function getLayouts($skip = array()) {
        $layouts = $this->_site->getLayoutFiles($this->field['type'], $skip, $this->conf['layouts']);
 
        // Nur bestimmte Layouts sind für diese Page erlaubt
        $info = $this->getTypeInfo();
        if (!empty($info['layouts'])) {
            return array_intersect_key($layouts, array_flip(explode(',', $info['layouts'])));
        }
 
        // Bestimmte Layouts deaktivieren
        if (!empty($this->conf['layouts'])) {
            foreach ($this->conf['layouts'] as $layout => $conf) {
                if ($conf['disabled']) {
                    unset($layouts[$layout]);
                }
            }
        }
 
        return $layouts;
    }
 
    public function isMovable() {
        $info = $this->getTypeInfo();
 
        // Darf es verschoben werden?
        if (array_key_exists('movable', $info)) {
            if ($info['movable']) {
                return true;
            }
            return false;
        }
 
        // Bildausschnitte dürfen nicht verschoben werden
        if ($this->extra['crop_image']) {
            return false;
        }
 
        // Nicht gesetzt -> Automatisch true
        return true;
    }
 
    public function getMovableList($type) {
        $info = $this->getTypeInfo();
        if (isset($info['movable_' . $type . 'list'])) {
            return array_map('trim', explode(',', $info['movable_' . $type . 'list']));
        }
        return null;
    }
 
    public function getTemplate($mobile = false, $name = 'body', $variant = '') {
        return $this->_site->getTemplate($mobile, $name, $this->field['type'], $variant ? $variant : (string) $this->extra['_template']);
    }
 
    public function getContents($orient) {
        return $this->extra['_contents'][$orient];
    }
 
    public function getScripts() {
        $scripts = array(
            $GLOBALS['egotec_conf']['site_dir'] . $this->_site->name . '/index.php',
            $this->_site->getSiteFile($this->field['type'] . '/index.php')
        );
        if ($this->_site->globalAllowed()) {
            // Für diesen Mandanten ein globales Skript verwenden
            array_unshift($scripts, $GLOBALS['egotec_conf']['site_dir'] . '_global/index.php');
        }
        if (!empty($this->_site->theme)) {
            array_splice($scripts, 2, 0, $this->_site->getSiteFile('index.php', array('module', 'custom', 'global', 'parent_custom')));
        }
        $existing_scripts = [];
        foreach ($scripts as $script) {
            if ($script && Ego_System::file_exists($script)) {
                $existing_scripts[] = $script;
            }
        }
        return $existing_scripts;
    }
 
    public function hasContent($orient = null) {
        if ($this->isFrontendAdmin(false)) {
            return $this->field['type'] != 'page' // @TODO Muss auch für andere Seitentypen funktionieren
                || (
                    isset($this->extra['_contents'])
                    && !empty($this->extra['_contents'])
                    && (
                        !$orient
                        || (
                            isset($this->extra['_contents'][$orient])
                            && !empty($this->extra['_contents'][$orient])
                        )
                    )
                );
        }
        return !Ego_System::isEmptyContent($this->field['content']);
    }
 
    public function hasBlock($block, $orient = '') {
        $n = 0;
        if (is_array($this->extra['_blocks'])) {
            foreach ($this->extra['_blocks'] as $_orient => $blocks) {
                if (!$orient || $orient == $_orient) {
                    $values = array_count_values($blocks);
                    if (isset($values[$block])) {
                        $n += $values[$block];
                    }
                }
            }
        }
        return $n;
    }
 
    public function addBlock($orient, $name, $content = [], $index = -1) {
        $content = array_merge([
            '_uid' => Ego_System::createUID()
        ], $content);
        $keys = [
            '_blocks' => $name,
            '_contents' => $content
        ];
        foreach ($keys as $key => $value) {
            if (!isset($this->extra[$key][$orient])) {
                $this->extra[$key][$orient] = [$value];
            } elseif ($index >= 0) {
                array_splice($this->extra[$key][$orient], $index, 0, [$value]);
            } else {
                $this->extra[$key][$orient][] = $value;
            }
        }
    }
 
    public function removeBlockByName($orient, $name) {
        if (isset($this->extra['_blocks'][$orient])) {
            $removed = false;
            while (($index = array_search($name, $this->extra['_blocks'][$orient])) !== false) {
                $this->removeBlockByIndex($orient, $index);
                $removed = true;
            }
            return $removed;
        }
        return false;
    }
 
    public function removeBlockByIndex($orient, $index) {
        if (isset($this->extra['_blocks'][$orient][$index])) {
            unset(
                $this->extra['_blocks'][$orient][$index],
                $this->extra['_contents'][$orient][$index]
            );
            $this->extra['_blocks'][$orient] = array_values($this->extra['_blocks'][$orient]);
            $this->extra['_contents'][$orient] = array_values($this->extra['_contents'][$orient]);
            return true;
        }
        return false;
    }
 
    public function removeAllBlocks(string $orients = ''): array {
        $array_return = [
            '_blocks' => [],
            '_contents' => []
        ];
 
        if ($orients != '') {
            foreach (explode(',', $orients) as $orient) {
                $array_return['_blocks'][$orient] = $this->extra['_blocks'][$orient];
                $array_return['_contents'][$orient] = $this->extra['_contents'][$orient];
 
                unset(
                    $this->extra['_blocks'][$orient],
                    $this->extra['_contents'][$orient]
                );
            }
        } else {
            $array_return['_blocks'] = $this->extra['_blocks'];
            $array_return['_contents'] = $this->extra['_contents'];
 
            unset(
                $this->extra['_blocks'],
                $this->extra['_contents']
            );
        }
 
        return $array_return;
    }
 
    public function getBlocks($orient, $variant = '', $page_frame = false) {
        // Wird diese Methode innerhalb eines Attach Element Templates aufgerufen, werden die Namen nicht erweitert
        $restore_value_prefix = '';
        if (isset($GLOBALS['_smarty_value_prefix'])) {
            $restore_value_prefix = $GLOBALS['_smarty_value_prefix'];
            unset($GLOBALS['_smarty_value_prefix']);
        }
 
        if ($variant == '') {
            if (isset($GLOBALS['_block_variant'])) {
                // Die Block Variante wird global weitergereicht
                $variant = $GLOBALS['_block_variant'];
            } elseif (in_array($_SERVER['REQUEST_SUFFIX'], array('.pdf', '.print'))) {
                // Block Varianten für .pdf und .print verwenden
                $variant = ltrim($_SERVER['REQUEST_SUFFIX'], '.');
            } elseif ($this->extra['_template']) {
                // Template Variante als Block Variante verwenden
                $variant = $this->extra['_template'];
            }
        }
        $layout = $this->extra['_layout'];
        $blocks = $this->extra['_blocks'][$orient];
 
        if (!is_array($blocks) || empty($blocks)) {
            // Standard Blöcke verwenden
            $blocks = array();
            if (empty($layout)) {
                $layout = $this->conf['default_layout']; // Standard Layout verwenden
            }
 
            if (!empty($this->conf['layouts'][$layout]['blocks'][$orient]['default'])) {
                // Standard Blöcke
                $blocks = explode(',', $this->conf['layouts'][$layout]['blocks'][$orient]['default']);
            }
            if (empty($blocks) && $orient == $this->mainOrient && $this->conf['template_block'] === true) {
                // Keine Blöcke und die Haupt-Orientierung: Immer das Standard Template verwenden
                $blocks[] = 'template';
            }
        }
 
        // Standard Template immer anzeigen, wenn
        if (
            $this->field['type'] != 'page' // ...nicht der Standard Seitentyp verwendet wird
        ) {
            // Der Seitentyp besitzt ein eigenes body Template und das Standard Template wird immer angezeigt
            // @TODO Nur wenn das Template aus dem Systemstandard kommt?
            $body_template = null;
            $default_template = $GLOBALS['egotec_conf']['lib_dir'] . 'type/skin/page/body.html';
            $get_body_template = function() use (&$body_template, $variant) {
                if (!$body_template) {
                    $body_template = $this->getTemplate($GLOBALS['is_mobile'], 'body', $variant);
                }
                return $body_template;
            };
 
            // Das Standard Template darf nicht entfernt werden, wenn
            if (
                $this->conf['blocks']['template']['removable'] !== true // ...nicht explizit das Entfernen erlaubt ist
                && $get_body_template() != $default_template // ...der Seitentyp ein eigenes body Template besitzt
            ) {
                $this->conf['blocks']['template']['removable'] = false;
            }
 
            // Das Standard Template muss für nicht Standard Seitentypen immer vorhanden sein
            if (
                $orient == $this->mainOrient // ...nur für die Haupt-Orientierung
                && !in_array('template', $blocks) // ...und das Standard Template nicht bereits eingebunden wird
                && $this->conf['blocks']['template']['removable'] !== true // ...außer es darf explizit entfernt werden
                && $get_body_template() != $default_template // ...der Seitentyp ein eigenes body Template besitzt
            ) {
                $blocks[] = 'template';
            }
        }
 
        // HTML aller Blöcke zusammenfügen
        $html = '';
        if (!empty($blocks)) {
            $system_blocks = $this->getSystemBlocks();
 
            foreach ($blocks as $index => $block) {
                if ($block != 'template' && isset($this->conf['blocks'][$block]['system']) && !isset($system_blocks[$block])) {
                    // Deaktivierte System Blöcke nicht anzeigen
                    continue;
                }
 
                if ($page_frame && $this->conf['blocks'][$block]['exclude']) {
                    // Blöcke, die für die Einbindung als dynamischer Inhalt ignoriert werden sollen, überspringen
                    continue;
                }
 
                $removable = !isset($this->conf['blocks'][$block]['removable']) || (bool) $this->conf['blocks'][$block]['removable'];
                $template = $this->getTemplateBlock($block, $orient, $index, false, false, $variant, $removable, false, $page_frame);
                if ($template === null) {
                    // Block existiert nicht
                    if ($GLOBALS['frontend_admin'] && $this->conf['orients'][$orient]['disabled'] !== true) {
                        // Einen unbekannten Block darstellen
                        $html .= $this->getTemplateBlock('unknown', $orient, $index, false, false, $variant, $removable, false, $page_frame);
                        $this->extra['_blocks'][$orient][$index] = 'unknown';
                        unset($this->extra['_contents'][$orient][$index]);
                    }
                    continue;
                }
 
                $html .= $template;
            }
        }
 
        // Formulare erweitern
        if (!empty($this->extra['_forms'][$orient])) {
            // Unsichtbare Formular Felder generieren
            if (!empty($this->extra['_forms'][$orient]['hidden'])) {
                require_once('base/Ego_Combo.php');
                $combo = new Ego_Combo($this->extra['_forms'][$orient]['hidden']);
                foreach ($combo->getData() as $field) {
                    $html .= '<input type="hidden" name="' . $field->key . '" value="' . $field->value . '">';
                }
            }
 
            // Mehrfachversand verhindern
            require_once 'base/Ego_ValidateForm.php';
            $html .= Ego_ValidateForm::generateToken($orient);
            $html .= Ego_ValidateForm::generateCSRF($orient);
 
            // Seiten mit Formularen immer ohne Cache ausliefern, da sonst der eindeutige Token/CSRF mehrfach verwendet werden kann
            $this->field['cache'] = 0;
        }
 
        // Vorangestellten Namen für Attach Element Templates wiederherstellen
        if (!empty($restore_value_prefix)) {
            $GLOBALS['_smarty_value_prefix'] = $restore_value_prefix;
        }
 
        return $html;
    }
 
    public function getBlock($orient, $uid, $variant = '', $page_frame = false) {
        $html = '';
        $blocks = $this->extra['_blocks'][$orient];
 
        if (is_numeric($uid)) {
            // Abwärtskompatibilität: UID ist die Position des Blocks
            $index = $uid;
            if (!empty($blocks) && isset($blocks[$index])) {
                $block = $blocks[$index];
 
                $removable = !isset($this->conf['blocks'][$block]['removable']) || (bool) $this->conf['blocks'][$block]['removable'];
                $template = $this->getTemplateBlock($block, $orient, $index, false, false, $variant, $removable, false, $page_frame);
                if ($template !== null) {
                    $html = $template;
                }
            }
        } elseif (is_array($blocks)) {
            foreach ($blocks as $index => $block) {
                if ($this->extra['_contents'][$orient][$index]['_uid'] == $uid) {
                    $removable = !isset($this->conf['blocks'][$block]['removable']) || (bool) $this->conf['blocks'][$block]['removable'];
                    $template = $this->getTemplateBlock($block, $orient, $index, false, false, $variant, $removable, false, $page_frame);
                    if ($template !== null) {
                        $html = $template;
                    }
                    break;
                }
            }
        }
 
        return $html;
    }
 
    private function getSystemBlocks() {
        $blocks = [];
 
        $system_conf = Ego_System::getJSON($GLOBALS['egotec_conf']['lib_dir'] . 'page/conf.json');
        foreach ($system_conf['blocks'] as $block => $conf) {
            $this->conf['blocks'][$block]['system'] = strpos($block, 'input_') === 0
                ? 'form'
                : 'system';
 
            if ($block != 'template' && empty($this->conf['no_' . $block])) {
                // Deaktivierte Systemeigene Blöcke ausschließen
                if (
                    isset($this->_site->admin['blocks']['overwrite'])
                    && !empty($this->_site->admin['blocks']['overwrite'])
                ) {
                    if (
                        isset($this->_site->admin['blocks']['system_disabled'])
                        && in_array($block, explode(',', $this->_site->admin['blocks']['system_disabled']))
                    ) {
                        continue;
                    }
                } elseif (
                    isset($GLOBALS['egotec_conf']['blocks']['system_disabled'])
                    && in_array($block, explode(',', $GLOBALS['egotec_conf']['blocks']['system_disabled']))
                ) {
                    continue;
                }
 
                if (!isset($this->conf['blocks'][$block])) {
                    $this->conf['blocks'][$block] = $conf;
                } else {
                    $this->conf['blocks'][$block] = array_merge($conf, $this->conf['blocks'][$block]);
                }
 
                $blocks[$block] = $conf['title'];
            }
        }
 
        return $blocks;
    }
 
    public function getBlockList($layout = null, $template = false, $for_orient = '') {
        $skip = !$this->_site->globalAllowed() ? ['global'] : [];
        $cache_key = 'blockList_' . md5(serialize(array(
            $layout,
            $template,
            $for_orient,
            $this->field['type'],
            $skip,
            $this->_site->language,
            $GLOBALS['auth']->isNobody() ? '' : $GLOBALS['auth']->user->field['user_id']
        )));
        $blocks = $this->_site->getCacheEntry($cache_key);
 
        if ($blocks === null) {
            // Sicherstellen, dass Block Informationen immer mit den Backend Übersetzungen ermitteln werden
            $original_smarty  = $GLOBALS['smarty'];
            unset($GLOBALS['translation'][$GLOBALS['t_language']]);
            $GLOBALS['smarty'] = Ego_Smarty::createAdmin($this->_site, array(
                'page' => $this
            ), true);
 
            $blocks = array();
 
            // Liste der verfügbaren Blöcke generieren (auch von übergeordneten Seitentypen erben)
            $block_files = [];
            $current_path = '';
            foreach (explode('/', $this->field['type']) as $path) {
                $current_path .= '/' . $path;
                $block_files = array_merge($block_files, $this->_site->getBlockFiles(ltrim($current_path, '/'), $skip));
            }
 
            // Systemeigene Blöcke hinzufügen
            $block_files = array_merge($block_files, $this->getSystemBlocks());
 
            $sort = array();
            foreach ($block_files as $block => $title) {
                if ($block == 'unknown') {
                    continue;
                } elseif ($block == '_empty') {
                    if ($this->conf['template_block'] !== true && !$template) {
                        continue;
                    }
                    // Das Standard Template ist immer verfügbar
                    $block = 'template';
                } elseif ($this->_site->isDisabledBlock($block)) {
                    // Block ist deaktiviert
                    continue;
                } elseif (empty($this->conf['blocks'][$block])) {
                    $this->conf['blocks'][$block] = array();
                }
                if (strpos($block, 'input_') === 0) {
                    // Formular Blöcke automatisch erweitern
                    if (!isset($this->conf['blocks'][$block]['system'])) {
                        $this->conf['blocks'][$block]['system'] = 'form';
                    }
                    if (!isset($this->conf['blocks'][$block]['group'])) {
                        $this->conf['blocks'][$block]['group'] = 'Formular';
                    }
                    if (!isset($this->conf['blocks'][$block]['controls'])) {
                        $this->conf['blocks'][$block]['controls'] = array();
                    }
                    array_unshift($this->conf['blocks'][$block]['controls'], array(
                        'type' => 'input',
                        'name' => substr(strrchr($block, '_'), 1)
                    ));
                }
                $blocks[$block] = array(
                    'title' => $GLOBALS['auth']->translate($this->conf['blocks'][$block]['title'] ? $this->conf['blocks'][$block]['title'] : $title),
                    'description' => $GLOBALS['auth']->translate((string)$this->conf['blocks'][$block]['description']),
                    'image' => $this->conf['blocks'][$block]['image'] ? $GLOBALS['egotec_conf']['url_dir'] . $this->conf['blocks'][$block]['image'] : '',
                    'max' => (int)$this->conf['blocks'][$block]['max'],
                    'translate' => $this->conf['blocks'][$block]['translate'] !== false
                );
                if (isset($this->conf['blocks'][$block]['index'])) {
                    $blocks[$block]['index'] = (int)$this->conf['blocks'][$block]['index'];
                }
                if (!empty($this->conf['blocks'][$block]['system'])) {
                    $blocks[$block]['system'] = $this->conf['blocks'][$block]['system'];
                }
                if ($controls = $this->getBlockControls($block)) {
                    $blocks[$block]['controls'] = $controls;
                }
                if (!empty($this->conf['blocks'][$block]['group'])) {
                    $groups = array();
                    foreach (explode(',', $this->conf['blocks'][$block]['group']) as $group) {
                        $groups[] = $GLOBALS['auth']->translate(trim($group));
                    }
                    $blocks[$block]['group'] = implode(',', $groups);
                }
                if (!empty($this->conf['blocks'][$block]['pattern'])) {
                    $blocks[$block]['pattern'] = array();
                    foreach (explode(',', $this->conf['blocks'][$block]['pattern']) as $index => $pattern) {
                        if (preg_match_all('/\[([^:=]+?)(:([^=]+?))?(=(.+?))?\]/', $pattern, $matches)) {
                            $blocks[$block]['pattern'][$index] = array();
                            foreach ($matches[0] as $index2 => $match) {
                                $width = $matches[1][$index2];
                                $type = (string) $matches[3][$index2];
                                $color = (string) $matches[5][$index2];
                                $data = array(
                                    'width' => $width,
                                    'color' => $color
                                );
                                if (strpos($type, 'image:') === 0) {
                                    $data['image'] = $GLOBALS['egotec_conf']['url_dir'] . substr($type, 6);
                                } else {
                                    $data['type'] = $type;
                                }
                                $blocks[$block]['pattern'][$index][] = $data;
                            }
                        }
                    }
                }
 
                $sort[] = mb_strtolower($blocks[$block]['title']);
            }
 
            // Blöcke alphabetisch sortieren
            array_multisort($sort, SORT_ASC, SORT_REGULAR, $blocks);
 
            // Blöcke variabel sortieren
            $index = 0;
            $sort = array();
            foreach ($blocks as $block => $info) {
                switch ($block) {
                    case 'page_frame':
                        // Dynamischer Inhalt als letzter Block
                        $i = sizeof($blocks) + 1;
                        break;
                    default:
                        if (strpos($block, 'input_') === 0) {
                            // Formular Elemente als vorletzte Blöcke
                            $i = sizeof($blocks);
                        } else {
                            // Individuelle Position
                            if (isset($info['index'])) {
                                $i = (int)$info['index'];
                                if ($i < 0) {
                                    // Negative Position ausgehend vom letzten Block
                                    $i = sizeof($blocks) - abs($i);
                                }
                            } elseif ($block == 'template') {
                                // Standard Template als erster Block, wenn nichts anderes angegeben ist
                                $i = 0;
                            } else {
                                $i = ++$index;
                            }
                        }
                }
                $sort[] = $i;
            }
            array_multisort($sort, SORT_ASC, SORT_NUMERIC, $blocks);
 
            if ($layout !== null) {
                // Alle Blöcke nach Orientierung gruppieren
                $block_list = array();
                if (!empty($this->conf['layouts'][$layout]['blocks'])) {
                    foreach ($this->conf['layouts'][$layout]['blocks'] as $orient => $info) {
                        $get_blocks = function ($block_list, $type) use ($layout, $info, &$get_blocks) {
                            $blocks = array();
                            if (!empty($info['extend_' . $type])) {
                                $block_list .= ",{$info['extend_'.$type]}";
                            }
                            foreach (explode(',', $block_list) as $block) {
                                if ($block[0] == '@') {
                                    // Blöcke einer anderen Orientierung für dieses Layout verwenden
                                    $orient_block_list = $this->conf['layouts'][$layout]['blocks'][substr($block, 1)][$type];
                                    if (!empty($orient_block_list)) {
                                        $blocks = array_merge($blocks, $get_blocks($orient_block_list, $type));
                                    }
                                } else {
                                    $blocks[] = $block;
                                }
                            }
                            return array_unique($blocks);
                        };
 
                        if (!empty($info['allow'])) {
                            // Nur erlaubte Blöcke ausgeben
                            $block_list[$orient] = array_intersect_key($blocks, array_flip($get_blocks($info['allow'], 'allow')));
                        } elseif (!empty($info['disallow'])) {
                            // Nicht erlaubte Blöcke nicht ausgeben
                            $block_list[$orient] = array_diff_key($blocks, array_flip($get_blocks($info['disallow'], 'disallow')));
                        }
                    }
                } elseif (!empty($for_orient)) {
                    $block_list[$for_orient] = $blocks;
                }
                // Gruppierung nach Haupt-Orientierung muss immer existieren
                if (empty($block_list[$this->mainOrient])) {
                    $block_list[$this->mainOrient] = $blocks;
                }
 
                $blocks = $block_list;
            }
 
            $this->_site->setCacheEntry($cache_key, $blocks);
            $GLOBALS['smarty'] = $original_smarty;
        }
 
        // Prüfen, ob dieses Layout Formulare beinhaltet
        $has_forms = $this->hasForms($layout);
 
        // Formular Blöcke für bestimmte Orientierungen nicht zurückliefern
        $filter = function($blocks) {
            $filtered = array();
            foreach ($blocks as $key => $block) {
                if (strpos($key, 'input_') !== 0) {
                    $filtered[$key] = $block;
                }
            }
            return $filtered;
        };
        if ($layout) {
            // Sicherstellen, dass die Orientierungen mit Formularen mindestens die Formular Blöcke anzeigen
            foreach ($has_forms as $orient) {
                if (empty($blocks[$orient])) {
                    $blocks[$orient] = $blocks[$this->mainOrient];
                }
                foreach ($blocks[$this->mainOrient] as $key => $block) {
                    if (strpos($key, 'input_') === 0 && !isset($blocks[$orient][$key])) {
                        $blocks[$orient][$key] = $block;
                    }
                }
            }
 
            foreach (array_keys($blocks) as $orient) {
                if (!in_array($orient, $has_forms)) {
                    $blocks[$orient] = $filter($blocks[$orient]);
                }
            }
        } elseif (empty($has_forms)) {
            $blocks = $filter($blocks);
        }
 
        if (!empty($for_orient)) {
            return $blocks[$for_orient];
        }
        return $blocks;
    }
 
    public function hasForms($layout = '') {
        $cache_key = 'hasForms'.md5(serialize(array($this->getIdentity(), $layout)));
        $has_forms = $this->_site->getCacheEntry($cache_key);
 
        if ($has_forms === null) {
            $conf_forms = $this->conf['layouts'][$layout ?: 'default']['form'];
            if (!empty($conf_forms)) {
                $this->_site->setCacheEntry($cache_key, $conf_forms);
                return $conf_forms;
            }
 
            if ($file = $this->getLayout(false, $layout)) {
                $has_forms = array();
 
                if (preg_match_all('/<form([^>]*)>(.*?)<\/form>/ims', Ego_System::file_get_contents($file), $matches)) {
                    foreach (array_keys($matches[0]) as $index) {
                        if (
                            // Das Formular ist bereits die Orientierung
                            preg_match('/data-edit-template=["\'](.+?)["\']/ims', $matches[1][$index], $match)
                            // Im Formular gibt es untergordnete Orientierungen
                            || preg_match('/<[^>]+data-edit-template=["\'](.+?)["\'][^>]*>/ims', $matches[2][$index], $match)
                        ) {
                            $has_forms[] = $match[1];
                        }
                    }
                }
                $has_forms = array_unique($has_forms);
 
                $this->_site->setCacheEntry($cache_key, $has_forms);
            }
        }
 
        return $has_forms;
    }
 
    public function getBlockControls($block) {
        if (isset($this->conf['blocks'][$block]['controls'])) {
            $controls = array();
            foreach ($this->conf['blocks'][$block]['controls'] as $control) {
                if ($control['name'][0] == '@') {
                    // Steuerelement wird geerbt
                    [$inherited_block, $name] = explode('.', substr($control['name'], 1));
                    if (isset($this->conf['blocks'][$inherited_block]['controls'])) {
                        foreach ($this->conf['blocks'][$inherited_block]['controls'] as $inherited_control) {
                            if ($inherited_control['name'] == $name) {
                                $merged_control = array_merge($inherited_control, $control);
                                $merged_control['name'] = $inherited_control['name'];
                                $controls[] = $merged_control;
                                break;
                            }
                        }
                    }
                } else {
                    $controls[] = $control;
                }
            }
            return $controls;
        }
        return null;
    }
 
    public function getTemplateBlock($block = 'template', $orient = '', $index = 0, $empty = false, $replace = false, $variant = '', $removable = true, $do_save = false, $page_frame = false, $element_types = [], &$smarty = null) {
        if ($orient == '') {
            $orient = $this->mainOrient;
        }
 
        // Merken, dass man sich im Block speichern Dialog befindet
        $GLOBALS['__egotec_edit_do_save'] = $do_save;
 
        // UID dieses Blocks
        $uid = $this->extra['_contents'][$orient][$index]['_uid'];
 
        $html = $class = '';
        $custom_html = false;
        if (!$smarty) {
            require_once('smarty/Ego_Smarty.php');
            $smarty = Ego_Smarty::createFrontend($this->_site, array(
                'page' => $this
            ), true);
        }
 
        // Das globale Smarty Objekt für das Block Template mit dem eigenen Smarty Objekt überschreiben, falls innerhalb des Blocks darauf zugegriffen wird
        $original_smarty = $GLOBALS['smarty'] ? $GLOBALS['smarty'] : $smarty;
        $GLOBALS['smarty'] = $smarty;
 
        // Falls das Extrafeld hier nicht existiert, wird es initialisiert
        if (empty($this->extra)) {
            $this->extra = unserialize($this->field['extra']);
        }
 
        // Standardwerte für Block Elemente und Extrafeld setzen
        if ($empty && !empty($this->conf['blocks'][$block]['default'][$orient])) {
            $this->extra['_contents'][$orient][$index] = $this->conf['blocks'][$block]['default'][$orient];
        }
 
        if (is_array($this->extra['_contents'][$orient][$index]['extra'])) {
            // Block Extrafeld als $extra übergeben
            $extra = $this->extra['_contents'][$orient][$index]['extra'];
 
            // Leeres Datum nicht übergeben
            foreach ($extra as $key => $value) {
                if (in_array($value, array('0000-00-00', '0000-00-00 00:00:00'), true)) {
                    unset($extra[$key]);
                }
            }
 
            if (strpos($block, 'input_') === 0) {
                // Formular Blöcke kriegen ihren ...
                if (isset($_POST[$extra['name']])) {
                    // ... aktuellen Wert übergeben
                    $smarty->assign('value', $_POST[$extra['name']]);
                    if (isset($_POST[$extra['name'] . '_input'])) {
                        $smarty->assign('value_input', $_POST[$extra['name'] . '_input']);
                    }
                } elseif ($block == 'input_checkbox') {
                    // ... aktuellen Wert übergeben (Checkbox Listen)
                    $values = array();
                    require_once 'base/Ego_Combo.php';
                    $combo = new Ego_Combo($extra['values']);
                    $new_data = array();
                    foreach ($combo->getData() as $data) {
                        if (isset($_POST[$data->field_name])) {
                            $values[] = $data->field_name;
                        }
 
                        // Darstellung für required/optional Checkboxen in Formular Blöcken
                        foreach (array('required', 'optional') as $type) {
                            if ($data->{$type}) {
                                $data->label = $GLOBALS['smarty']->fetch('string:' . str_replace('<%>', $data->label, $this->conf['form'][$type] ?? $data->label));
                            }
                        }
                        $new_data[] = $data;
                    }
 
                    // Geänderte Daten übernehmen
                    if (empty($new_data) && isset($extra['name'])) {
                        // Abwärtskompatibilität: alte, einzelne Checkbox darstellen
                    } else {
                        $combo->setData($new_data);
                        $extra['values'] = $combo->getString();
                    }
 
                    $smarty->assign('values', $values);
                } elseif (empty($_POST['sendform'][$orient]) && isset($extra['default'])) {
                    // ... Standardwert übergeben
                    $smarty->assign('value', $extra['default']);
                }
 
                // Formular Block deaktivieren
                if (!empty($extra['disabled'])) {
                    $smarty->assign('disabled', true);
                }
 
                // Regulärer Ausdruck für die E-Mail Validierung
                $smarty->assign(array(
                    'email_pattern' => Ego_System::REGEX_EMAIL,
                    'email_pattern_optional' => Ego_System::REGEX_EMAIL_OPTIONAL,
                    'pattern_optional' => $extra['regex'] ? '$|' . $extra['regex'] : ''
                ));
            }
        }
 
        // Fehler bei der Validierung anzeigen
        if (
            strpos($block, 'input_') === 0
            && isset($GLOBALS['_sendform_error'])
            && $GLOBALS['_sendform_error']['orient'] == $orient
            && (
                $GLOBALS['_sendform_error']['index'] == $index
                || (
                    $GLOBALS['_sendform_error']['block'] == 'input_captcha'
                    && $block == $GLOBALS['_sendform_error']['block']
                )
            )
        ) {
            $smarty->assign('error', $GLOBALS['_sendform_error']['title']);
        }
 
        $smarty->assign('extra', $extra ?? []);
        unset($smarty->_plugins['outputfilter'], $smarty->autoload_filters['output']);
 
        // Diesen Block in der Frontend Administration anzeigen
        $frontend_admin = $GLOBALS['frontend_admin'] && $this->conf['orients'][$orient]['disabled'] !== true;
 
        if ($block == 'template') {
            // Das Template des Seitentyps
            if ($page_frame) {
                /* Wird das Template als dynamischer Inhalt eingebunden, muss das Skript eingebunden werden.
                 * Andernfalls wird es bereits beim direkten Aufruf des Seitentyps eingebunden. */
                $include_type_script = function() use ($block, $orient, $index, $extra, $smarty, $variant) {
                    if (
                        (
                            $variant
                            && ($file = $this->_site->getSiteFile("{$this->field['type']}/index.{$variant}.php"))
                        ) || ($file = $this->_site->getSiteFile("{$this->field['type']}/index.php"))
                    ) {
                        // Weitere Variablen im Skript verfügbar machen
                        $page = $this;
                        $site = $page->getSite();
                        $auth = $GLOBALS['auth'];
 
                        require_once $file;
                    }
                };
                $include_type_script();
            }
 
            $html .= $this->fetch(array(
                '_layout' => $this->extra['_layout'],
                '_orient' => $orient,
                '_index' => $index,
                '_block' => $block,
                '_empty' => $empty,
                '_replace' => $replace,
                '_page' => &$this
            ), false, (bool) $GLOBALS['__egotec_edit_request'], false, $variant);
        } else {
            // Ein bestimmtes Template
            $block_found = false;
            $suffixes = array('.tpl', '.html');
            if ($variant) {
                // Block Varianten zuerst suchen
                array_unshift($suffixes, ".{$variant}.tpl", ".{$variant}.html");
            }
            foreach ($suffixes as $file_suffix) {
                if (
                    ($file = $this->_site->getInheritedFile('skin', $this->field['type'], "blocks/{$block}{$file_suffix}"))
                    || ($file = $this->_site->getSkinFile("blocks/{$block}{$file_suffix}"))
                    || Ego_System::file_exists($file = $GLOBALS['egotec_conf']['lib_dir'] . "page/t/blocks/{$block}.tpl")
                ) {
                    $this->blockProperties = array(
                        '_layout' => $this->extra['_layout'],
                        '_orient' => $orient,
                        '_index' => $index,
                        '_block' => $block,
                        '_empty' => $empty,
                        '_replace' => $replace,
                        '_uid' => $uid
                    );
                    $smarty->assign(array_merge(
                        $this->blockProperties,
                        array('_page' => &$this)
                    ));
 
                    $include_block_script = function() use ($block, $orient, $index, $extra, $smarty, $uid, $variant) {
                        // Weitere Variablen im Skript verfügbar machen
                        $page = $this;
                        $site = $page->getSite();
                        $auth = $GLOBALS['auth'];
 
                        // Globales Block Skript einbinden
                        if (
                            (
                                $variant
                                && ($file = $this->_site->getSiteFile("blocks.{$variant}.php"))
                            ) || ($file = $this->_site->getSiteFile('blocks.php'))
                        ) {
                            require $file;
                        }
 
                        // Block spezifisches Skript einbinden
                        if (
                            (
                                $variant
                                && (
                                    ($file = $this->_site->getSiteFile("{$this->field['type']}/blocks/{$block}.{$variant}.php"))
                                    || ($file = $this->_site->getSiteFile("blocks/{$block}.{$variant}.php"))
                                )
                            ) || ($file = $this->_site->getSiteFile("{$this->field['type']}/blocks/{$block}.php"))
                            || ($file = $this->_site->getSiteFile("blocks/{$block}.php"))
                            || Ego_System::file_exists($file = $GLOBALS['egotec_conf']['lib_dir'] . "page/blocks/{$block}.php")
                        ) {
                            require $file;
                        }
                    };
                    $include_block_script();
 
                    if ($controls = $this->getBlockControls($block)) {
                        $domQuery = null;
                        $dom = function() use ($smarty, $file) {
                            require_once('base/Ego_DomQuery.php');
                            $smarty_clone = clone $smarty;
                            return new Ego_DomQuery($smarty_clone->fetch($file));
                        };
 
                        // Alle Attach Elemente vorab durchgehen
                        $element_vars = $element_vars_default = [];
                        foreach ($controls as $control) {
                            if ($control['type'] == 'attach') {
                                $max = 0;
                                if (!$empty && !empty($this->extra['_contents'][$orient][$index][$control['name']])) {
                                    $max = sizeof($this->extra['_contents'][$orient][$index][$control['name']]);
                                }
                                if ($frontend_admin && !$control['optional'] && $max == 0) {
                                    // Wenn keine Elemente vorhanden sind, dann x Elemente automatisch annehmen
                                    $max = $control['start'] ?? 1;
                                }
                                $element_vars[$control['name']] = $element_vars_default[$control['name']] = [
                                    'index' => min($max, $control['start'] ?? 1) - 1,
                                    'count' => $max
                                ];
                            }
                        }
 
                        foreach ($controls as $ci => $control) {
                            switch ($control['type']) {
                                // Block kann um Elemente erweitert werden
                                case 'attach':
                                    // Template generieren
                                    $custom_html = true;
 
                                    // Anzahl anzuzeigender Elemente ermitteln
                                    $max = $element_vars[$control['name']]['count'];
 
                                    foreach ($control['elements'] as $ei => $element) {
                                        $n = 0;
                                        $items = '';
                                        $multiple_items = is_array($element['items']);
                                        while ($n < $max) {
                                            $i = 0;
                                            if ($multiple_items) {
                                                $j = $element_types[$ci][$ei] ?? 0;
                                                if (isset($this->extra['_contents'][$orient][$index][$control['name']][$n]['_type'])) {
                                                    $j = (int) $this->extra['_contents'][$orient][$index][$control['name']][$n]['_type'];
                                                }
                                                $item = $element['items'][$j]['item'];
                                                $script = $element['items'][$j]['script'];
                                                $values = $element['items'][$j]['values'];
                                            } else {
                                                $item = $element['item'];
                                                $script = $element['script'];
                                                $values = $element['values'];
                                            }
 
                                            // Element Informationen an Smarty übergeben
                                            $element_vars[$control['name']] = array_merge(array_filter($this->extra['_contents'][$orient][$index][$control['name']][$n] ?? [], function($key) {
                                                return $key != '_element';
                                            },  ARRAY_FILTER_USE_KEY), $element_vars_default[$control['name']]);
                                            $element_vars[$control['name']]['index'] = $n;
                                            $smarty->assign('_element', $element_vars);
 
                                            // Skript ausführen
                                            if (!empty($script) && ($file = $this->_site->getSiteFile($script))) {
                                                $load_script = function($file) use (&$smarty, $extra, $element_vars) {
                                                    $element = $element_vars;
                                                    require $file;
                                                };
                                                $load_script($file);
                                            }
 
                                            // HTML ermitteln aus...
                                            if (strpos($item, '@') === 0) {
                                                // ...einer Datei
                                                $GLOBALS['_smarty_value_prefix'] = "{$control['name']}][$n][";
                                                $items .= $smarty->fetch('string:' . Ego_System::file_get_contents($this->_site->getSkinFile(substr($item, 1))));
                                                unset($GLOBALS['_smarty_value_prefix']);
                                            } else {
                                                // ...einem String
                                                $items .= $smarty->fetch('string:' . preg_replace_callback('/<%>/', function () use ($values, $n, &$i, $control) {
                                                        // Smarty {value} erzeugen
                                                        $func = '{value';
                                                        foreach ($values[$i] as $attr => $value) {
                                                            if ($attr == 'var') {
                                                                $value = "{$control['name']}][$n][$value";
                                                            }
                                                            if (is_array($value)) {
                                                                foreach ($value as $sub_attr => $sub_value) {
                                                                    $func .= " {$attr}.{$sub_attr}=\"{$sub_value}\"";
                                                                }
                                                            } else {
                                                                $func .= " {$attr}=\"{$value}\"";
                                                            }
                                                        }
                                                        $func .= '}';
                                                        $i++;
                                                        return $func;
                                                    }, str_replace(['<#>', '<##>'], [$n + 1, $max], $item)
                                                ));
                                            }
 
                                            // Erstes Element aktiv setzen
                                            if ($n == 0 && $element['active']) {
                                                $domQuery2 = new Ego_DomQuery($items);
                                                $nodes = $domQuery2->query($element['active']['selector']);
                                                foreach ($nodes as $node) {
                                                    if ($element['active']['attribute'] == 'class') {
                                                        if ($className = $node->getAttribute('class')) {
                                                            $classes = explode(' ', $className);
                                                        } else {
                                                            $classes = array();
                                                        }
                                                        $classes[] = $element['active']['value'];
                                                        $node->setAttribute('class', implode(' ', $classes));
                                                    } else {
                                                        $node->setAttribute($element['active']['attribute'], $element['active']['value']);
                                                    }
                                                    $items = $domQuery2->getHTML();
                                                    break;
                                                }
                                            }
 
                                            $n++;
                                        }
 
                                        // Platzhalter mit Smarty und HTML ersetzen
                                        if ($domQuery === null) {
                                            $domQuery = $dom();
                                        }
                                        $domQuery->setInnerHTML($domQuery->query($element['selector']), function($node) use ($items) {
                                            return $items;
                                        });
                                    }
                                    break;
 
                                // Eine Seite auswählen und die Daten im Block verwenden
                                case 'page':
                                    $identity = $this->extra['_contents'][$orient][$index][$control['name']];
                                    if (
                                        !empty($identity)
                                        && ($data = Page::byIdentity($identity))
                                        && $data->getIdentity() !== $this->getIdentity() // Die aktuelle Seite nicht einbinden
                                    ) {
                                        // Sprachversion verwenden, falls vorhanden
                                        if (
                                            $data->getSite()->language != $this->getSite()->language
                                            && ($lang_data = $data->getLanguagePage($this->getSite()->language))
                                        ) {
                                            $data = $lang_data;
                                        }
 
                                        $smarty->assign([
                                            $control['name'] => $data,
                                            "{$control['name']}_block" => $this->extra['_contents'][$orient][$index][$control['name'] . '_block']
                                        ]);
                                    }
                                    break;
 
                                // Block kann den Wert eines Nodes ändern
                                case 'option':
                                    $value = $this->extra['_contents'][$orient][$index][$control['name']];
                                    if (
                                        (
                                            $control['attribute'] == '#text'
                                            || $control['preset'] == 'materialize'
                                        )
                                        && !empty($value)
                                    ) {
                                        $domQuery = $dom();
                                        $domQuery->setInnerHTML($domQuery->query($control['selector']), function($node) use ($value, &$custom_html) {
                                            $custom_html = true;
                                            return $value;
                                        });
                                    }
                            }
                        }
 
                        if ($domQuery && $custom_html) {
                            $html .= $domQuery->getHTML();
                        }
                    }
 
                    if (!$custom_html) {
                        // Template ausgeben
                        $html .= $smarty->fetch($file);
                    }
 
                    unset($this->blockProperties);
                    $block_found = true;
                    break;
                }
            }
 
            if (!$block_found) {
                // Block existiert nicht
                $GLOBALS['smarty'] = $original_smarty;
                return null;
            }
        }
 
        // Bei einem Formular Block das Template erweitern
        if ($this->conf['form']['wrapper']) {
            $replace_form = false; // Erweitertes HTML muss am Ende mit dem FORM Element im Original HTML ersetzt werden
            if (strpos($block, 'input_') === 0) {
                $form_html = $html;
            } elseif (
                $block == 'medialist'
                && !empty($this->extra['_contents'][$orient][$index]['extra'])
                && preg_match('/<form[^>]*>.*?<\/form>/ims', $html, $matches)
            ) {
                // Upload Formular für den Block "Medienliste" erweitern
                $form_html = $matches[0];
                $replace_form = true;
            } else {
                $form_html = '';
            }
 
            if ($form_html != '') {
                if (is_array($this->conf['form']['values'])) {
                    // Der Wrapper führt weitere {value} Elemente ein
                    $element = $this->conf['form'];
                    $i = 0;
                    $form_html = $smarty->fetch('string:' . preg_replace_callback('/<%>/', function() use ($element, &$i, $form_html, $block) {
                            if (empty($element['values'][$i])) {
                                // Ein leeres Element markiert wo der eigentliche Formular Block eingefügt wird
                                return $form_html;
                            } else {
                                // Smarty {value} erzeugen
                                $func = '{value';
                                foreach ($element['values'][$i] as $attr => $value) {
                                    if (is_array($value)) {
                                        foreach ($value as $sub_attr => $sub_value) {
                                            $func .= " {$attr}.{$sub_attr}=\"{$sub_value}\"";
                                        }
                                    } else {
                                        $func .= " {$attr}=\"{$value}\"";
                                    }
                                }
                                $func .= '}';
                            }
                            $i++;
                            return $func;
                        }, $this->conf['form']['wrapper']));
                } else {
                    $form_html = str_replace('<%>', $form_html, $this->conf['form']['wrapper']);
                }
 
                // Formular Block wird unterteilt
                $columns = $this->extra['_contents'][$orient][$index]['extra']['_columns'];
                if (!$columns) {
                    $columns = (string) $this->conf['form']['columns']['default'];
                }
                if (isset($this->conf['form']['columns']['value'])) {
                    $columns = str_replace('<%>', $columns, $this->conf['form']['columns']['value']);
                }
                $columns = trim($columns);
 
                $form_html = str_replace(
                    '<|>',
                    $frontend_admin
                        ? '' // Im Backend wird die Unterteilung auf das Block Element angewendet
                        : $columns,
                    $form_html
                );
 
                if ($replace_form) {
                    $html = preg_replace('/<form[^>]*>.*?<\/form>/ims', $form_html, $html);
                } else {
                    $html = $form_html;
                }
            }
        }
 
        // Standard Block HTML modifizieren
        $modify_list = array_filter([
            $this->conf['blocks'][$block]['modify'], // Modifikationen nur für diesen Block
            $this->conf['modify'] // Modifikationen für alle Blöcke
        ]);
        if (!empty($modify_list)) {
            require_once('base/Ego_DomQuery.php');
            $domQuery = new Ego_DomQuery($html);
            $domQuery->setSmarty($smarty);
            $domQuery->setSite($this->getSite());
            $changed = false;
 
            foreach ($modify_list as $modify_entry) {
                foreach ($modify_entry as $modify) {
                    if (isset($modify['scope']) && $modify['scope'] == 'document') {
                        continue;
                    }
 
                    // Platzhalter setzen
                    if (isset($modify['value'])) {
                        $placeholders = [
                            'orient' => $orient,
                            'index' => $index,
                            'block' => $block,
                            'id' => $this->field['id'],
                            'uid' => $uid
                        ];
                        foreach ($placeholders as $placeholder => $value) {
                            $modify['value'] = str_replace("<%{$placeholder}>", $value, $modify['value']);
                        }
                    }
 
                    $domQuery->modify($modify, true);
                    $changed = true;
                }
            }
 
            if ($changed) {
                $html = $domQuery->getHTML();
            }
        }
 
        // Sprungmarke platzieren
        if (!empty($this->extra['_contents'][$orient][$index]['_anchor'])) {
            $anchor = "<a id=\"{$this->extra['_contents'][$orient][$index]['_anchor']}\"></a>\n";
 
            if (!empty($this->conf['anchor'])) {
                // An eine bestimmte Position im Block HTML
                require_once('base/Ego_DomQuery.php');
                $domQuery = new Ego_DomQuery($html);
                $domQuery->setSmarty($smarty);
                $domQuery->setSite($this->getSite());
 
                $domQuery->insertNode($anchor, $this->conf['anchor']);
 
                $html = $domQuery->getHTML();
            } else {
                // An den Anfang des Block HTML
                $html = $anchor . $html;
            }
        }
 
        // Berechnete Block Styles ermitteln
        $hash = md5(implode('-', [$this->getIdentity(), $block, $orient, $index]));
        $cache_key = 'blockStyles' . $hash;
        $cached_tpl = $this->_site->getCacheEntry($cache_key);
        if ($cached_tpl === null) {
            $cached_tpl = [];
        }
        if (
            (
                ($tpl = $cached_tpl[$block]) !== null
                || ($tpl = $this->_site->getSkinFile("{$this->field['type']}/blocks/$block.style.tpl"))
                || ($tpl = $this->_site->getSkinFile("{$this->field['type']}/blocks/$block.style.html"))
                || ($tpl = $this->_site->getSkinFile("blocks/$block.style.tpl"))
                || ($tpl = $this->_site->getSkinFile("blocks/$block.style.html"))
            )
            && $tpl !== ''
        ) {
            $css_file = $GLOBALS['egotec_conf']['bin_dir'] . 'tmp/' . $hash . '.css';
            Ego_System::file_put_contents($css_file, $smarty->fetch($tpl));
            $css_file = $GLOBALS['egotec_conf']['url_dir'] . 'bin/tmp/' . basename($css_file);
            $html .= "\n" . '<link rel="stylesheet" property="stylesheet" href="' . $css_file . '">';
        } else {
            $tpl = '';
        }
        $cached_tpl[$block] = $tpl;
        $GLOBALS['site']->setCacheEntry($cache_key, $cached_tpl);
 
        $GLOBALS['smarty'] = $original_smarty;
 
        // CSS Klasse für diesen Block automatisch setzen
        if (!empty($this->conf['blocks'][$block]['class'])) {
            $class = $this->conf['blocks'][$block]['class'];
        }
 
        // Block spezifische Dateien einbinden (CSS, JS)
        if (empty($this->conf['blocks'][$block]['no_files'])) {
            $patterns = array(
                "blocks/{$block}",
                "{$this->field['type']}/blocks/{$block}"
            );
            foreach (array('css', 'js') as $extension) {
                foreach ($patterns as $pattern) {
                    $path = "$pattern.$extension";
                    if ($file = $this->_site->getSkinFile($path, array(), true)) {
                        $html .= Ego_System::includeHtml($file);
                    }
                }
            }
        }
 
        // Block als eingeschwärzt markieren
        if ($this->extra['_contents'][$orient][$index]['_classified']) {
            $classes = explode(' ', $class);
            $classes[] = 'egotec-classified';
            $class = implode(' ', array_filter($classes));
        }
 
        if (empty($_REQUEST['page_block_preview']) && (!$frontend_admin || !$this->isCurrentPage())) {
            return trim($class ? '<div class="' . $class . '">' . $html . '</div>' : $html);
        }
 
        // CSS Klasse für die Unterteilung wird im Backend auf das Block Element angewendet
        if (!empty($columns)) {
            $class = trim($class . $columns);
        }
 
        if (trim($html) == '' && $this->isCurrentPage()) {
            // Damit leere Elemente bedient werden können, erhalten diese einen Platzhalter
            $title = $block;
            if ($this->conf['blocks'][$block]['title']) {
                $title = $GLOBALS['auth']->translate($this->conf['blocks'][$block]['title']);
            }
            $html = '<div data-edit-empty-block="' . $title . '"></div>';
        }
 
        // Zugehörige Gruppe bestimmen
        if (strpos($block, 'input_') === 0 && !isset($this->conf['blocks'][$block]['group'])) {
            // Formular Blöcke automatisch erweitern
            $this->conf['blocks'][$block]['group'] = 'Formular';
        }
        $group = (string) $this->conf['blocks'][$block]['group'];
        if ($group) {
            $group = $GLOBALS['auth']->translate($group);
        }
 
        // Bestimmte Optionen als Attribute im Adminbereich setzen
        $backend_options = '';
        if (!empty($this->conf['panel']['options'])) {
            foreach ($this->conf['panel']['options'] as $option => $name) {
                $value = Ego_System::getAssocValue($this->extra, implode('.', ['_contents', $orient, $index, $name]));
                if ($value !== null) {
                    $backend_options .= ' data-edit-option-' . $option . '="' . $value . '"';
                }
            }
        }
 
        return trim('<div data-edit-block="' . $block . '" data-edit-block-index="' . $index . '" data-edit-block-uid="' . $uid . '"'
            . (
                ($group ? ' data-edit-group="' . $group . '"' : '')
                . (!$removable ? ' data-edit-static="true"' : '')
                . (!empty($columns) ? ' data-edit-columns="true"' : '')
            )
            . $backend_options
            . ($class ? ' class="' . $class . '"' : '')
            . '>' . $html . '</div>');
    }
 
    public function inheritBlocks() {
        if (!empty($this->conf['layouts'][$this->extra['_layout']]['inherit'])) {
            if (isset($this->extra['_inherit_disabled']) && !empty($this->extra['_inherit_disabled'])) {
                return 2;
            }
            foreach (explode(',', $this->conf['layouts'][$this->extra['_layout']]['inherit']) as $orient) {
                $blocks_key = implode('.', array('_blocks', $orient));
                $contents_key = implode('.', array('_contents', $orient));
                $extra = $this->inheritExtra(array($blocks_key, $contents_key));
                if ($extra[$blocks_key] !== null) {
                    $checksum_blocks = Ego_System::getChecksum($extra[$blocks_key]);
                    $checksum_original = Ego_System::getChecksum($this->extra['_blocks'][$orient]);
 
                    if ($checksum_blocks != $checksum_original) {
                        $checksum_contents = Ego_System::getChecksum($extra[$contents_key]);
                        $this->extra['_inherited'][$orient] = array(
                            'blocks' => $checksum_blocks,
                            'contents' => $checksum_contents
                        );
                    }
                }
                foreach ($extra as $key => $value) {
                    $this->extra[strstr($key, '.', true)][$orient] = $value;
                }
            }
            return 1;
        }
        return 0;
    }
 
    public function getFormats($type = '') {
        // Standard Formate
        $formats = [
            'headers' => [
                'title' => 'Headers',
                'items' => [
                    ['title' => 'Header 1', 'format' => 'h1'],
                    ['title' => 'Header 2', 'format' => 'h2'],
                    ['title' => 'Header 3', 'format' => 'h3'],
                    ['title' => 'Header 4', 'format' => 'h4'],
                    ['title' => 'Header 5', 'format' => 'h5'],
                    ['title' => 'Header 6', 'format' => 'h6']
                ]
            ],
            'inline' => [
                'title' => 'Inline',
                'items' => [
                    ['title' => 'Bold', 'icon' => 'bold', 'format' => 'bold'],
                    ['title' => 'Italic', 'icon' => 'italic', 'format' => 'italic'],
                    ['title' => 'Underline', 'icon' => 'underline', 'format' => 'underline'],
                    ['title' => 'Strikethrough', 'icon' => 'strike-through', 'format' => 'strikethrough'],
                    ['title' => 'Superscript', 'icon' => 'superscript', 'format' => 'superscript'],
                    ['title' => 'Subscript', 'icon' => 'subscript', 'format' => 'subscript'],
                    ['title' => 'Code', 'icon' => 'sourcecode', 'format' => 'code']
                ]
            ],
            'blocks' => [
                'title' => 'Blocks',
                'items' => [
                    ['title' => 'Paragraph', 'format' => 'p'],
                    ['title' => 'Blockquote', 'format' => 'blockquote'],
                    ['title' => 'Div', 'format' => 'div'],
                    ['title' => 'Pre', 'format' => 'pre']
                ]
            ],
            'alignment' => [
                'title' => 'Alignment',
                'items' => [
                    ['title' => 'Left', 'icon' => 'align-left', 'format' => 'alignleft'],
                    ['title' => 'Center', 'icon' => 'align-center', 'format' => 'aligncenter'],
                    ['title' => 'Right', 'icon' => 'align-right', 'format' => 'alignright'],
                    ['title' => 'Justify', 'icon' => 'align-justify', 'format' => 'alignjustify']
                ]
            ]
        ];
 
        // Bei aktiver Checkbox "Einschwärzen aktivieren" unter Mandant -> Editor die Option PDF einschwärzen unter Formate -> Inline in TinyMCE anzeigen
        if ($this->getSite()->admin['editor']['allow_classified']) {
            $formats['inline']['items'][] = ['title' => 'Im Druck einschwärzen', 'icon' => 'invert', 'inline' => 'span', 'classes' => 'egotec-classified'];
        }
 
        // Individuelle Formate
        if (isset($this->conf['formats'])) {
            $custom_formats = $type && isset($this->conf['formats'][$type])
                ? $this->conf['formats'][$type] // Formate für einen bestimmten Editor anpassen
                : $this->conf['formats']['default']; // Formate für alle Editoren anpassen
 
            if (is_array($custom_formats)) {
                foreach ($custom_formats as $name => $values) {
                    // Wenn es die Format Liste gibt, wird sie erweitert/überschrieben
                    if (isset($formats[$name])) {
                        // Standard Formate überschreiben
                        if (is_array($values) && $values['options']) {
                            $new_items = [];
 
                            foreach (explode(',', $values['options']) as $option) {
                                foreach ($formats[$name]['items'] as $item) {
                                    if ($item['format'] == $option) {
                                        // Die Sortierung der Standard Formate entspricht der angegebenen Reihenfolge
                                        $new_items[] = $item;
                                        break;
                                    }
                                }
                            }
                            $formats[$name]['items'] = $new_items;
                        }
 
                        if (isset($values) && empty($values)) {
                            // Wenn es keine Formate gibt, wird auch keine Liste angezeigt
                            unset($formats[$name]);
                        } elseif (is_array($values) && isset($values['items'])) {
                            // Formate nur bearbeiten, wenn es eigene gibt
 
                            if ($values['merge']) {
                                // Existierende Formate erweitern
                                $items = $formats[$name]['items'];
 
                                if (is_array($values['items'])) {
                                    foreach ($values['items'] as $custom_item) {
                                        if (($index = array_search($custom_item['title'], array_column($items, 'title'))) !== false) {
                                            $items[$index] = $custom_item;
                                        } else {
                                            $items[] = $custom_item;
                                        }
                                    }
                                }
                            } else if (is_array($values['items'])) {
                                // Existierende Formate überschreiben
                                $items = $values['items'];
                            }
 
                            if (!empty($items)) {
                                $formats[$name] = [
                                    'title' => $formats[$name]['title'],
                                    'items' => $items
                                ];
                            } else {
                                // Wenn es keine Formate gibt, wird auch keine Liste angezeigt
                                unset($formats[$name]);
                            }
                        }
                    } else {
                        // Neue Format Liste hinzufügen
                        $formats[$name] = $values;
                    }
                }
            }
        }
 
        return array_values($formats);
    }
 
    public function getToolbar($type = '') {
        $result = array(
            'plugins' => '',
            'menubar' => '',
            'toolbar' => '',
            'contextmenu' => '',
            'menu' => [
                'edit' => [
                    'title' => 'Edit',
                    'items' => 'undo redo | pastetext selectall | searchreplace'
                ],
                'insert' => [
                    'title' => 'Insert',
                    'items' => 'link | charmap egotecIcons | anchor | egotecAccessibility'
                ],
                'view' => [
                    'title' => 'View',
                    'items' => 'visualaid visualchars visualblocks'
                ],
                'table' => [
                    'title' => 'Table',
                    'items' => 'inserttable | cell row column | tableprops deletetable'
                ],
                'tools' => [
                    'title' => 'Tools',
                    'items' => 'egotecCode | help'
                ]
            ]
        );
 
        // Standard Toolbar
        switch ($type) {
            case 'editor':
                $result['plugins'] = 'advlist autolink lists egotecLink image charmap anchor searchreplace visualblocks visualchars media table importcss help '
                    . 'egotecSpellchecker egotecPageFrame egotecImageScale egotecList egotecMaxLength egotecIcons egotecAccessibility';
                $result['menubar'] = 'edit insert view table tools';
                $result['toolbar'] = 'styles removeformat | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist egotecBullist egotecNumlist | outdent indent | media image link unlink | egotecSpellchecker';
                $result['menu']['insert']['items'] .= ' | image media | table';
                $result['contextmenu'] = 'table | ';
                break;
 
            case 'content':
                $result['plugins'] = 'advlist autolink lists egotecLink charmap anchor searchreplace visualblocks visualchars importcss help '
                    . 'egotecSpellchecker egotecSplit egotecList egotecMaxLength egotecIcons egotecAccessibility';
                $result['menubar'] = 'edit insert view tools';
                $result['toolbar'] = 'styles removeformat | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist egotecBullist egotecNumlist | outdent indent | link unlink | egotecSpellchecker | egotecSplit';
                break;
 
            case 'minimal':
                $result['plugins'] = 'autolink egotecLink anchor '
                    . 'egotecSpellchecker egotecSplit egotecAccessibility';
                $result['toolbar'] = 'bold italic | link unlink | egotecSpellchecker | egotecSplit';
                break;
 
            case 'table':
                $result['plugins'] = 'advlist autolink lists egotecLink charmap anchor searchreplace visualblocks visualchars table importcss help '
                    . 'egotecSpellchecker egotecList egotecMaxLength egotecAccessibility egotecTable';
                $result['menubar'] = 'edit insert view tools';
                $result['toolbar'] = 'styles removeformat | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist egotecBullist egotecNumlist | outdent indent | link unlink | egotecSpellchecker |  egotecSplit';
                $result['contextmenu'] = 'cell row column | ';
                break;
 
            case 'text':
                $result['plugins'] = 'egotecSpellchecker egotecSplit egotecPlainText egotecMaxLength egotecAccessibility';
                $result['toolbar'] = 'egotecSpellchecker | egotecSplit';
        }
 
        // Alle Editoren verwenden das selbe Kontextmenü
        $result['contextmenu'] .= 'link | egotecAccessibility egotecSpellchecker-suggestions';
 
        if ($this->_site->hasRight("admin")) {
            // Quelltext Plugin hinzufügen
            $result['plugins'] .= ' egotecCode';
        }
 
        // Das "egotecFix" Plugin immer laden
        $result['plugins'] .= ' egotecFix';
 
        // Individuelle Toolbar
        if (!empty($this->conf['toolbar'])) {
            $custom_toolbar = $this->conf['toolbar'][$type];
            foreach (array_keys($result) as $name) {
                if (isset($custom_toolbar[$name])) {
                    if (in_array($custom_toolbar[$name], ['', false], true)) {
                        $result[$name] = false;
                    } elseif (preg_match_all('/[+-]?[^+-]+/', $custom_toolbar[$name], $matches) !== false) {
                        foreach ($matches[0] as $toolbar) {
                            $toolbar = trim(str_replace(',', ' ', rtrim($toolbar, ',')), ' |');
                            if (strpos($toolbar, '+') === 0) {
                                // Eigenschaften hinzufügen
                                $result[$name] .= ' ' . substr($toolbar, 1);
                            } elseif (strpos($toolbar, '-') === 0) {
                                // Eigenschaften entfernen
                                $pattern = '/(^| )(' . str_replace(' ', '|', preg_quote(substr($toolbar, 1))) . ')(|$)/';
                                $result[$name] = preg_replace($pattern, '', $result[$name]);
                            } else {
                                // Eigenschaften überschreiben
                                $result[$name] = $toolbar;
                            }
                        }
                    }
                }
            }
        }
 
        return $result;
    }
 
    public function getHtml($root = false) {
        $html = '';
        $type_path = explode('/', $this->field['type']);
        $type_info = $this->getTypeInfo();
        $inherit = isset($type_info['inherit']) ? explode(',', (string) $type_info['inherit']) : [
            'style', 'script' // Alles erben
        ];
        $variant = '';
        if ($this->extra['_style']) {
            $variant = '.'.$this->extra['_style'];
        }
        $suffix = $_SERVER['REQUEST_SUFFIX'] != '.html' ? $_SERVER['REQUEST_SUFFIX'] : '';
        $current_path = '';
        foreach ($type_path as $path) {
            $current_path .= $path.'/';
            if (
                (
                    in_array('style', $inherit)
                    || rtrim($current_path, '/') == $this->field['type']
                )
                && (
                    ($suffix != '' && ($src = $this->_site->getSkinFile($current_path.'style'.$suffix.'.css', array('system'), true)))
                    || ($variant != '' && ($src = $this->_site->getSkinFile($current_path.'style'.$variant.'.css', array('system'), true)))
                    || ($src = $this->_site->getSkinFile($current_path.'style.css', array('system'), true))
                )
            ) {
                $html .= Ego_System::includeHtml($src);
            }
            if (
                (
                    in_array('script', $inherit)
                    || rtrim($current_path, '/') == $this->field['type']
                )
                && ($src = $this->_site->getSkinFile($current_path.'script.js', array(), true))
            ) {
                $html .= Ego_System::includeHtml($src);
            }
        }
 
        // style.css und script.js aus dem root Verzeichnis einbinden
        if ($root) {
            if (
                ($suffix != '' && ($src = $this->_site->getSkinFile('style'.$suffix.'.css', array('system'), true)))
                || ($variant != '' && ($src = $this->_site->getSkinFile('style'.$variant.'.css', array('system'), true)))
                || ($src = $this->_site->getSkinFile('style.css', array('system'), true))
            ) {
                $html .= Ego_System::includeHtml($src);
            }
            if ($src = $this->_site->getSkinFile('script.js', array('system'), true)) {
                $html .= Ego_System::includeHtml($src);
            }
        }
 
        return $html;
    }
 
    protected function getOrient($orient = null) {
        if ($orient === null) {
            $orient = $this->mainOrient; // Standardwert
            if (isset($this->blockProperties['_orient'])) {
                $orient = $this->blockProperties['_orient'];
            }
        }
        return $orient;
    }
 
    protected function getIndex($index = null) {
        if ($index === null) {
            $index = 0; // Standardwert
            if (isset($this->blockProperties['_index'])) {
                $index = $this->blockProperties['_index'];
            }
        }
        return $index;
    }
 
    public function getValue($name, $orient = null, $index = null, $verbose = false) {
        // Orientierung und Index automatisch setzen
        $orient = $this->getOrient($orient);
        $index = $this->getIndex($index);
 
        // Mehrere Werte prüfen
        if (strpos($name, ',') !== false) {
            foreach (explode(',', $name) as $sub_name) {
                $value = $this->getValue($sub_name, $orient, $index, $verbose);
                if ($value !== null) {
                    return $value;
                }
            }
        }
 
        // Einen Wert in einem Array finden
        if (($pos = strpos($name, '.?.')) !== false) {
            $array = $this->getValue(substr($name, 0, $pos), $orient, $index, $verbose);
            if (is_array($array)) {
                foreach ($array as $i => $value) {
                    $value = $this->getValue(substr($name, 0, $pos) . ".$i." . substr($name, $pos + 3), $orient, $index, $verbose);
                    if ($value !== null) {
                        return $value;
                    }
                }
            }
            return null;
        }
 
        // Zu durchsuchende Werte
        $extra = unserialize($this->field['extra']);
 
        $value = Ego_System::getAssocValue($extra, implode('.', array('_contents', $orient, $index, $name)));
        if ($value !== null) {
            if ($verbose) {
                // Alle zugehörigen Werte ebenfalls zurückliefern
                $array = array(
                    'value' => $value
                );
                if (($pos = strrpos($name, '.')) !== false) {
                    $key = implode('.', array('_contents', $orient, $index, substr($name, 0, $pos)));
                    $name = substr($name, $pos + 1);
                } else {
                    $key = implode('.', array('_contents', $orient, $index));
                }
                $values = Ego_System::getAssocValue($extra, $key);
                if (is_array($values)) {
                    foreach ($values as $key => $value) {
                        if (strpos($key, "{$name}_") === 0) {
                            $array[substr($key, strlen("{$name}_"))] = $value;
                        } elseif ($key == 'extra') {
                            $array[$key] = $value;
                        }
                    }
                }
                return $array;
            } else {
                return $value;
            }
        }
        return null;
    }
 
    public function getValues($name, $orient = null, $verbose = false) {
        // Orientierung automatisch setzen
        $orient = $this->getOrient($orient);
 
        $values = array();
        if (is_array($this->extra['_contents'][$orient])) {
            $list = $this->extra['_contents'][$orient];
            if (is_array($list)) {
                foreach (array_keys($list) as $index) {
                    $value = $this->getValue($name, $orient, $index, $verbose);
                    if ($value !== null) {
                        $values[] = $value;
                    }
                }
            }
        }
        return $values;
    }
 
    public function getFirstValue($name, $orient = null, $verbose = false) {
        // Orientierung automatisch setzen
        $orient = $this->getOrient($orient);
 
        if (is_array($this->extra['_contents'][$orient])) {
            $list = $this->extra['_contents'][$orient];
            if (is_array($list)) {
                foreach (array_keys($list) as $index) {
                    $value = $this->getValue($name, $orient, $index, $verbose);
                    if ($value !== null) {
                        return $value;
                    }
                }
            }
        }
        return null;
    }
 
    public function getFirstMediaValue(string $name, string $type = 'image', string $orient = null, bool $verbose = false) {
        $orient = $this->getOrient($orient);
        $list = $this->extra['_contents'][$orient];
 
        if (is_array($list)) {
            foreach (array_keys($list) as $index) {
                $value = $this->getValue($name, $orient, $index, $verbose);
                if ($value !== null && $this->extra['_contents'][$orient][$index][$name . '_type'] == $type) {
                    return $value;
                }
            }
        }
        return null;
    }
 
 
    public function getBlockValue($block, $name, $orient = null, $index = null, $verbose = false) {
        // Orientierung und Index automatisch setzen
        $orient = $this->getOrient($orient);
        $index = $this->getIndex($index);
 
        if ($this->extra['_blocks'][$orient][$index] == $block) {
            $value = $this->getValue($name, $orient, $index, $verbose);
            if ($value !== null) {
                return $value;
            }
        }
        return null;
    }
 
    public function getBlockValues($block, $name, $orient = null, $verbose = false) {
        // Orientierung automatisch setzen
        $orient = $this->getOrient($orient);
 
        $values = array();
        if (is_array($this->extra['_blocks'][$orient])) {
            foreach ($this->extra['_blocks'][$orient] as $index => $block_name) {
                if ($block_name == $block) {
                    $value = $this->getValue($name, $orient, $index, $verbose);
                    if ($value !== null) {
                        $values[] = $value;
                    }
                }
            }
        }
        return $values;
    }
 
    public function getFirstBlockValue($block, $name, $orient = null, $verbose = false) {
        // Orientierung automatisch setzen
        $orient = $this->getOrient($orient);
 
        if (is_array($this->extra['_blocks'][$orient])) {
            foreach ($this->extra['_blocks'][$orient] as $index => $block_name) {
                if ($block_name == $block) {
                    $value = $this->getValue($name, $orient, $index, $verbose);
                    if ($value !== null) {
                        return $value;
                    }
                }
            }
        }
        return null;
    }
 
    public function merge($id, $replicate = true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'merge';
        }
 
        $original_page = $this->_site->getPage($id, array(
            'auth_or' => '1=1',
            'deleted_or' => '1=1',
            'inactive' => true,
            'only_active' => false
        ));
        if (!$original_page) {
            return null;
        }
        $field = $this->field;
        $extra = $this->extra;
 
        unset($field['children']);
        if ($field['children_order'] == 'children') {
            // Die Reihenfolge der Kinder neu festlegen
            $children_list = array();
            $original_children = explode(',', trim($extra['original_children'], ','));
            $current_children = $original_page->getChildren(array(), array('auth_or' => '1=1'));
            $current_children_list = array();
            foreach ($current_children as $child) {
                $current_children_list[] = $child->field['id'];
            }
            foreach ($original_children as $child_id) {
                $key = array_search($child_id, $current_children_list);
                if ($key !== false) {
                    $children_list[] = $child_id;
                    unset($current_children_list[$key]);
                }
            }
            $children_list = array_merge($children_list, $current_children_list);
        }
 
        $field['inactive'] = $extra['original_inactive'];
 
        unset(
            $extra['original_id'],
            $extra['original_children'], // @TODO Die original_children werden nicht gelöscht.
            $extra['original_inactive'],
            $extra['workflow_page']
        );
        if ($extra['original_parents']) {
            $original_parents = $extra['original_parents'];
            unset($extra['original_parents']);
        }
 
        // Alle neu erstellten Kinder auf das Original übertragen.
        $children = $this->getChildren();
        foreach ($children as $child) {
            $child->move($this->field['id'], $original_page->field['id']);
            $child->updateField(array('inactive' => self::ACTIVE_FLAG));
        }
 
        unset($field['id']);
        unset($field['parents']);
        unset($field['workflow_state']);
        if (isset($original_page->field['workflow'])) {
            $field['workflow'] = $original_page->field['workflow'];
        } else {
            unset($field['workflow']);
        }
        if (isset($original_page->extra['workflows'])) {
            $extra['workflows'] = $original_page->extra['workflows'];
        } else {
            unset($extra['workflows']);
        }
 
        // Ist die Zielseite eine Freigabekopie, dann wird dieser Status beibehalten
        if (!$original_page->isReleaseCopy()) {
            unset($extra['release_id']);
            if ($field['inactive'] == self::RELEASE_FLAG) {
                $field['inactive'] = 0;
            }
        }
 
        if (!is_numeric($field['inactive'])) {
            $field['inactive'] = 0; // Im Zweifel immer aktivieren
        }
        // Liegt das Freigabe ab Datum in der Zukunft, wird es entfernt (nur für Freigabekopien)
        if ($this->isReleaseCopy() && $field['release_from'] > date('Y-m-d H:i:s')) {
            $field['release_from'] = '0000-00-00 00:00:00';
        }
 
        $update = array(
            'field' => $field,
            'extra' => $extra
        );
 
        if ($children_list) {
            $update['children'] = $children_list;
        }
 
        if ($original_parents) {
            $current_parents = array();
            foreach ($this->getParents(array('fields' => 'id')) as $parent) {
                $current_parents[] = $parent->field['id'];
            }
            $update['parents'] = $current_parents;
        }
 
        $original_page->field = array_merge($original_page->field, $update['field']);
        if ($original_page->extra['release_ids']) {
            // Freigabekopie Liste aktualisieren
            $update['extra']['release_ids'] = array_values(array_diff($original_page->extra['release_ids'], array($this->field['id'])));
        }
        $original_page->extra = $update['extra']; // Nicht zusammenführen. Das neue Extra überschreibt das alte komplett.
 
        /* Evtl. vorhandene MM-Datei kopieren */
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$this->getMediaFilename())) {
            Ego_System::copy(
                $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$this->getMediaFilename(),
                $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->_site->name.'/'.$original_page->getMediaFilename(true)
            );
        }
 
        // Mediapool kopieren
        $this->getMediapool()->copy($original_page, $this->getMediapool()->currentDir);
        $this->getMediapool()->copy($original_page, 'workflow', false, true);
 
        // Jetzt Bearbeitungsdatum ändern und Archiveintrag anlegen
        $original_page->update([
            'field' => $original_page->field,
            'extra' => $original_page->extra,
            'parents' => $update['parents'],
            'children' => $update['children']
        ]);
 
        $this->delete();
 
        if ($replicate) {
            $this->replicate('merge', $id);
        }
 
        return $original_page;
    }
 
    public function newRelease($date = '') {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'newRelease';
        }
 
        if ($this->field['inactive'] != self::RELEASE_FLAG) {
            $this->archiveOnly = false;
            $field = $this->field;
            $extra = $this->extra;
            unset($field['id']);
            $field['inactive'] = self::RELEASE_FLAG;
            if ($date != '') {
                $field['release_from'] = $date;
            }
 
            if ($this->isWorkflowCopy()) {
                // Wenn es sich um eine Workflowkopie handelt wird diese zur Freigabekopie
                $extra['release_id'] = $extra['original_id'];
                unset($extra['original_id']);
                $new_page = $this;
            } else {
                // Eine neue Freigabekopie erstellen
                $extra['release_id'] = $this->field['id'];
                unset($extra['release_ids']);
                $parents = $this->getParents(array(), array('auth_or' => '1=1'));
                if ($parent = $parents->nextPage()) {
                    $new_page = $parent->newChild($field, $extra);
                }
                if (empty($new_page)) {
                    // Existiert keine Elternseite, dann unter sich selbst erstellen (Startseite)
                    $new_page = $this->newChild($field, $extra);
                }
            }
            if ($new_page) {
                // Freigabekopie Liste aktualisieren
                $original_page = $this->_site->getPage($extra['release_id'], array(
                    'only_active' => false,
                    'inactive' => true
                ));
                $extra = $original_page->extra;
                if (!is_array($extra['release_ids'])) {
                    $extra['release_ids'] = array();
                }
                $extra['release_ids'][] = $new_page->field['id'];
                $extra['release_ids'] = array_unique($extra['release_ids']);
                $original_page->updateExtra($extra, true, true);
 
                $this->replicate('newRelease', $date);
 
                return $new_page;
            }
        }
 
        return null;
    }
 
    public function release() {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'release';
        }
 
        if ($this->isReleaseCopy()) {
            // Gibt es ein Freigabe bis Datum, wird vom Original eine neue Freigabekopie mit Freigabe ab Datum angelegt
            if (
                $this->field['release_until'] != '0000-00-00 00:00:00'
                && ($original_page = $this->_site->getPage($this->extra['release_id'], array(
                    'inactive' => true,
                    'only_active' => false
                )))
                && $original_page->field['release_until'] == '0000-00-00 00:00:00' // Nur wenn das Original kein Freigabe bis Datum hat
            ) {
                $release_ids = $original_page->extra['release_ids'] ?? array();
                $original_page->extra['release_ids'] = array_values(array_diff($release_ids, array($this->field['id'])));
                $GLOBALS['new_release'] = $original_page->newRelease($this->field['release_until']);
 
                // Das Freigabe bis Datum muss bei der aktuellen Veröffentlichung entfernt werden
                $this->field['release_until'] = '0000-00-00 00:00:00';
            }
 
            $this->replicate('release');
 
            return $this->merge($this->extra['release_id'], false);
        }
        return null;
    }
 
    public function getWorkflowHistory() {
        require_once 'workflow/Ego_Workflow.php';
        require_once 'base/template/Ego_Template_Mail.php';
        require_once 'base/Ego_Combo.php';
        require_once 'rights/User_SQL.php';
 
        $history = array();
 
        $tmp_history = $this->extra['history'];
        if (is_array($this->extra['history'])) {
            $deleted = 0;
            foreach ($this->extra['history'] as $workflow_id => $list) {
                if (!is_array($list)) {
                    continue;
                }
 
                $workflow = new Ego_Workflow($workflow_id);
                $group = array();
                $grouped_list = array();
 
                ksort($list, SORT_NUMERIC);
                foreach ($list as $time => $entry) {
                    $cleared = false;
                    $clear = false;
                    if ($entry['old_phase'] == '-' && !$group['start']) {
                        // Start
                        $group['start'] = $time;
                    } elseif ($entry['old_phase'] == '-' && $group['start']) {
                        // Abgebrochen ohne Ende
                        $grouped_list[] = $group;
                        $group = array();
                        $group['start'] = $time;
                    } elseif (
                        (
                            $entry['new_phase'] == '1'
                            && (
                                !$entry['comment']
                                || !preg_match(
                                    '/^\{APPROVAL:.*?\}$/msi',
                                    $entry['comment']
                                ) // Genehmigung für den letzten Status
                            )
                        )
                        || $entry['new_phase'] == 'c'
                    ) {
                        // Ende
                        $group['end'] = $time;
                        $clear = true;
                    }
 
                    // Benutzername
                    if ($entry['user'] != 'SYSTEM') {
                        $user = new_db_connection(array(
                            'table' => 'egotec_user',
                            'where' => 'user_id = :user_id',
                            'bind' => array(
                                'user_id' => $entry['user']
                            )
                        ));
                        if ($user->nextRecord()) {
                            $user_sql = new User_SQL($user->Record['user_id'], $user->Record);
                            $entry['username'] = $user_sql->getFullname();
                        }
                    }
 
                    // Status
                    $entry['old_phase_name'] = $workflow->extra['phases'][$entry['old_phase']]['name'];
                    $entry['new_phase_name'] = $workflow->extra['phases'][$entry['new_phase']]['name'];
                    if (preg_match('/^\{SWITCH:([^:]+):([^:]+)\}$/ims', $entry['comment'], $matches)) {
                        $from = new Ego_Workflow($matches[1]);
                        $to = new Ego_Workflow($matches[2]);
                        $msg = $GLOBALS['auth']->translate('Wechsel von <b>%from</b> nach <b>%to</b>');
                        $msg = str_replace('%from', $from->field['name'], $msg);
                        $msg = str_replace('%to', $to->field['name'], $msg);
                        $entry['comment'] = '';
                        $entry['system'] = $msg;
                    }
 
                    // Freigeber
                    if (preg_match('/^\{APPROVAL:([^:]+)\}$/ims', $entry['comment'], $matches)) {
                        $msg = $GLOBALS['auth']->translate('Genehmigung von <b>%user</b>');
                        try {
                            $user = new User_SQL($matches[1]);
                            $msg = str_replace('%user', $user->getFullname(), $msg);
                        } catch (User_Exception $e) {
                            $msg = str_replace('%user', $GLOBALS['auth']->translate('unbekannt'), $msg);
                        }
                        $entry['comment'] = '';
                        $entry['system'] = $msg;
                    }
 
                    // Informationen zu den Aktionen
                    if (is_array($entry['actions'])) {
                        foreach ($entry['actions'] as $key => $action) {
                            $info = '';
                            switch ($action['type']) {
                                case 'move':
                                    if ($action['parent']) {
                                        $parent = Ego_System::urltopage($action['parent']);
                                        if ($parent) {
                                            $info = $GLOBALS['auth']->translate('Die Seite wurde verschoben nach %parent.');
                                            $parent_site = $parent->getSite();
                                            $url = $GLOBALS['egotec_conf']['url_dir'].'admin.php?site='.$parent_site->name.'&lang='.$parent_site->language.'&list='.$parent->field['id'];
                                            $info = str_replace('%parent', '<a href="'.$url.'">'.$parent->field['name'].'</a>', $info);
                                        }
                                    }
                                    break;
                                case 'cancel':
                                    // Keine Informationen
                                    break;
                                case 'switch':
                                    if ($action['workflow']) {
                                        $new_workflow = new Ego_Workflow($action['workflow']);
                                        $info = $GLOBALS['auth']->translate('Der Workflow wurde gewechselt zu %workflow.');
                                        $info = str_replace('%workflow', $new_workflow->field['name'], $info);
                                    }
                                    break;
                                case 'email':
                                    if ($action['template']) {
                                        $list = array();
                                        try {
                                            if (is_string($action['recipients'])) {
                                                $recipients = (array) json_decode($action['recipients']);
                                                if (!empty($recipients)) {
                                                    foreach ($recipients as $type => $combo) {
                                                        $combo = new Ego_Combo($combo);
                                                        switch ($type) {
                                                            case 'cc':
                                                                $suffix = ' (<span style=\'color:#2dabff !important;\'>CC</span>)';
                                                                break;
                                                            case 'bcc':
                                                                $suffix = ' (<span style=\'color:#e63f2d !important;\'>BCC</span>)';
                                                                break;
                                                            default:
                                                                $suffix = '';
                                                        }
                                                        foreach ($combo->getRights() as $r) {
                                                            $list[] = '<b>'.$r['group']->field['group_name'].'/'.$r['role']->field['role_name'].'</b>'.$suffix;
                                                        }
                                                        foreach ($combo->getUsers() as $u) {
                                                            $list[] = '<u>'.$u->getFullname().'</u>'.$suffix;
                                                        }
                                                        foreach ($combo->getText() as $text) {
                                                            $list[] = '<i>'.$text.'</i>'.$suffix;
                                                        }
                                                    }
                                                }
                                            }
                                            if (!empty($list)) {
                                                $info = $GLOBALS['auth']->translate('Die E-Mail wurde versendet an:').'<br/>';
                                                $info .= implode(', ', $list);
                                            } else {
                                                try {
                                                    $template = new Ego_Template_Mail($action['template']);
                                                    $info = $GLOBALS['auth']->translate('Die E-Mail wurde versendet an die Empfänger des Templates:').'<br/>'.$template->field['name'];
                                                } catch (Ego_Template_Exception $e) {
                                                    $info = $GLOBALS['auth']->translate('Die E-Mail wurde nicht versendet, da ein ungültiges Template ausgewählt ist.');
                                                }
                                            }
                                        } catch (Exception $e) {
                                            // Ignorieren
                                        }
                                    }
                                    break;
                                case 'editor':
                                    $list = array();
                                    if (is_string($action['combo'])) {
                                        $combo = new Ego_Combo($action['combo']);
 
                                        foreach ($combo->getRights() as $r) {
                                            $list[] = '<b>'.$r['group']->field['group_name'].'/'.$r['role']->field['role_name'].'</b>';
                                        }
                                        foreach ($combo->getUsers() as $u) {
                                            $list[] = '<u>'.$u->getFullname().'</u>';
                                        }
                                    }
                                    if (!empty($list)) {
                                        $info = $GLOBALS['auth']->translate('Folgende Bearbeiter wurden ausgewählt:').'<br/>';
                                        $info .= implode(', ', $list);
                                    }
                                    break;
                                case 'approval':
                                    $list = array();
                                    if (is_string($action['approval_users'])) {
                                        $combo = new Ego_Combo($action['approval_users']);
 
                                        foreach ($combo->getUsers() as $u) {
                                            $list[] = '<u>'.$u->getFullname().'</u>';
                                        }
                                    }
                                    if (!empty($list)) {
                                        $info = $GLOBALS['auth']->translate('Folgende Freigeber wurden ausgewählt:').'<br/>';
                                        $info .= implode(', ', $list);
                                    }
                                    break;
                                case 'script':
                                    if ($action['file']) {
                                        $info = $GLOBALS['auth']->translate('Folgendes Skript wurde ausgeführt:').'<br/>';
                                        $info .= $action['file'];
                                    }
                            }
                            if (empty($info)) {
                                $info = $GLOBALS['auth']->translate('Es sind keine Informationen verfügbar.');
                            }
                            $entry['actions'][$key]['_info'] = $info;
                        }
                    }
 
                    if (!is_array($group['list'])) {
                        $group['list'] = array();
                    }
                    $entry['time'] = $time;
                    $group['list'][$time] = $entry;
                    if ($clear) {
                        $grouped_list[] = $group;
                        $group = array();
                        $cleared = true;
                    }
                }
                if (empty($cleared) && !empty($group)) {
                    // Die laufende Historie auch anzeigen wenn diese nicht abgeschlossen ist
                    $grouped_list[] = $group;
                }
 
                $history[] = array(
                    'id' => $workflow_id,
                    'name' => $workflow->field['name'],
                    'list' => $grouped_list
                );
            }
        }
 
        return $history;
    }
 
    public function isWorkflowCopy() {
        return ($this->field['workflow'] && $this->extra['original_id']);
    }
 
    public function isReleaseCopy() {
        return ($this->extra['release_id'] && $this->field['inactive'] == self::RELEASE_FLAG);
    }
 
    public function isClone() {
        return !empty($this->extra['clone_original']);
    }
 
    public function isLanguageLink()
    {
        return ($this->extra['language_link'][$this->getSite()->language] && $this->extra['language_standard'] != $this->getSite()->language);
    }
 
    public function isArchive() {
        return $this->archiveOnly || $this->getTableSuffix() == '_v';
    }
 
    public function isActive() {
        return !$this->field['inactive']
            && !$this->field['deleted']
            && ($this->field['release_from'] == '0000-00-00 00:00:00' || date('Y-m-d H:i:s') > $this->field['release_from'])
            && ($this->field['release_until'] == '0000-00-00 00:00:00' || date('Y-m-d H:i:s') < $this->field['release_until'])
            && !$this->isWorkflowCopy()
            && !$this->isReleaseCopy();
    }
 
    public function isClassified() {
        return $this->getSite()->admin['editor']['allow_classified'] && !empty($this->extra['_classified']);
    }
 
    public function getNonPublic() {
        if ($this->isPublicSave()) {
            $db = new_db_connection();
            $db->select(array(
                'table' => $this->_site->pageTable . '_v',
                'where' => 'id = :id AND m_date > :c_date',
                'order' => 'm_date DESC',
                'limit' => 1,
                'bind' => array(
                    'id' => $this->field['id'],
                    'c_date' => $this->lastChangeDate
                )
            ));
            if ($db->nextRecord()) {
                $class = $this->_site->getPageClass($db->Record['type']);
                return new $class($this->_site, $db->Record);
            }
        }
        return null;
    }
 
    public function isPublicSave() {
        return $this->_site->isPublicSave()
            && !$this->isWorkflowCopy()
            && !$this->isReleaseCopy()
            && ($info = $this->getTypeInfo(false))
            && !$info['no_public_save'];
    }
 
    public function isPublic() {
        if ($this->isPublicSave()) {
            return $this->lastChangeDate == $this->field['m_date'];
        }
        return true;
    }
 
    public function getLastChangeDate() {
        return $this->lastChangeDate;
    }
 
    public function getArchivePage($c_date = '') {
        $db = new_db_connection();
        $params = array(
            'table' => $this->_site->pageTable.'_v',
            'where' => 'id = :id',
            'order' => 'm_date DESC',
            'limit' => 1,
            'bind' => array(
                'id' => $this->field['id']
            )
        );
        if ($c_date) {
            // Archiveintrag zu einem bestimmten Zeitpunkt
            $params['where'] .= ' AND m_date = :c_date';
            $params['bind']['c_date'] = $c_date;
        }
        $db->select($params);
        if ($db->nextRecord()) {
            $page = clone $this;
            $page->setTableSuffix('_v');
            $page->field = $db->Record;
            $page->extra = $db->Record['extra']
                ? unserialize($db->Record['extra'])
                : array();
            return $page;
        }
        return null;
    }
 
    public function getArchivePages($query=array())
    {
        $query['table'] = $this->getSite()->pageTable . '_v';
        if ($query['where']) {
            $query['where'].= ' AND ';
        }
        $query['where'].= 'id=:id';
        $query['bind']['id'] = $this->field['id'];
        if (!isset($query['order'])) {
            $query['order'] = 'm_date DESC';
        }
        return new Page_Iterator($this->_site, new_db_connection($query));
    }
 
    public function restoreArchivPage($c_date)
    {
        $db = new_db_connection();
        $db->select(array(
            'table'     => $this->getSite()->pageTable.'_v',
            'where'     => "id=".$this->field['id']." AND m_date='".$c_date."'"
        ));
 
        if (!$db->nextRecord()) {
            return false;
        }
 
        /* Einige Daten werden nicht wieder aus dem Archiv überschrieben */
        $field = $db->Record;
        unset($field['id']);
        unset($field['children']);
        unset($field['parents']);
        $extra = unserialize($field['extra']);
 
        // Dazugehöriges Mediapool Archiv wiederherstellen
        $this->getMediapool()->restore(Ego_System::dateEncode($c_date));
 
        if (empty($extra['piwik']) && !empty($this->extra['piwik'])) {
            // Die Piwik Einstellungen beim Wiederherstellen beibehalten
            $extra['piwik'] = $this->extra['piwik'];
        }
        $this->update(array(
            'field' => $field,
            'extra' => $extra
        ));
 
        if ($file = $this->getSite()->getSiteFile($this->field['type'].'/admin/archive_restore.php')) {
            // Diese Variablen müssen zur Abwärtskompatibilität gesetzt sein
            $site = $this->getSite();
            $current_page = $this;
            $smarty = $GLOBALS['smarty'];
            require($file);
        }
 
        return true;
    }
 
    public function download($recursive = true, $target_dir = '', $write_log = true) {
        $log = $GLOBALS['egotec_conf']['log_dir'].'page_download-'.date('Y-m-d');
        if ($write_log) {
            file_put_contents($log, "\r\n===> ".date('Y-m-d H:i:s')
                ." Page Download für "
                ."{$this->_site->name}.{$this->_site->language}.{$this->field['id']}"
                ." beginnt:\r\n", FILE_APPEND);
        }
        if ($target_dir) {
            $dir = $target_dir;
        } else {
            $dir = $GLOBALS['egotec_conf']['tmp_dir'].'download'.md5(microtime()).'/';
        }
        $media_dir = $dir.'media/'.$this->_site->name.'/';
        if ($write_log) {
            file_put_contents($log, "Verzeichnisse anlegen\r\n", FILE_APPEND);
        }
        Ego_System::mkdir($dir);
        Ego_System::mkdir($media_dir);
        $params = array(
            'inactive' => true,
            'only_active' => false,
            'no_cache' => true,
            'auth_or' => '1=1'
        );
 
        $pages = array($this);
        if ($recursive) {
            if ($write_log) {
                file_put_contents($log, "Alle Nachfahren ermitteln\r\n", FILE_APPEND);
            }
            foreach ($this->getDescendants(
                array(),
                $params
            ) as $descendant) {
                $pages[] = $descendant;
            }
        }
 
        $data = array();
        $db = new_db_connection();
        Ego_System::mkdir($dir.'db/');
        foreach ($pages as $page) {
            if ($write_log) {
                file_put_contents($log, "Seite {$page->field['name']} ({$page->field['id']}) sichern\r\n", FILE_APPEND);
            }
            foreach ($this->_site->getLanguages() as $lang) {
                $lang_page = $page->getLanguagePage($lang);
                if ($write_log) {
                    file_put_contents($log, "> Sprache {$lang} sichern\r\n", FILE_APPEND);
                }
 
                // Haupttabelle sichern
                $table = $this->_site->name.'_'.$lang;
                $db->select(array(
                    'table' => $table,
                    'fields' => '*',
                    'where' => 'id = :id',
                    'bind' => array(
                        'id' => $page->field['id']
                    )
                ));
                while ($db->nextRecord()) {
                    $s = serialize($db->Record);
                    $file = $dir.'db/'.$table;
                    file_put_contents($file, strlen($s)."\n".$s, FILE_APPEND);
 
                    $path = $GLOBALS['egotec_conf']['var_dir']
                        .'media/'.$this->_site->name.'/';
 
                    // Mediapool
                    if (Ego_System::file_exists($path.$lang.'/pool/'.$page->field['id'].'/')) {
                        if ($write_log) {
                            file_put_contents($log, "> Mediapool sichern\r\n", FILE_APPEND);
                        }
                        Ego_System::mkdir($media_dir.$lang.'/pool/'.$page->field['id'].'/');
                        Ego_System::copy(
                            $path.$lang.'/pool/'.$page->field['id'].'/',
                            $media_dir.$lang.'/pool/'.$page->field['id'].'/'
                        );
                    }
 
                    // Multimedia
                    if (
                        in_array($page->field['type'], array('multimedia/file', 'multimedia/image'))
                        && $lang_page
                    ) {
                        if ($write_log) {
                            file_put_contents($log, "> Datei sichern\r\n", FILE_APPEND);
                        }
                        $file = $lang_page->getMediaFilename();
                        Ego_System::mkdir($dir.'media/'.$this->_site->name.'/'.$lang);
                        @copy(
                            $path.$file,
                            $dir.'media/'.$this->_site->name.'/'.$lang.'/'.$page->field['id']
                        );
                    }
                }
 
                // Alle verknüpften Tabellen sichern
                $tables = array(
                    'buchungen' => $table.'_buchungen',
                    'children' => $table.'_children',
                    'extra' => $table.'_extra',
                    'infodienst' => $table.'_infodienst',
                    'newsletter_light' => $table.'_newsletter_light',
                    'rights' => $table.'_rights',
                    'users' => $table.'_users',
                    'keywords' => $this->_site->name.'_keywords_rel',
                    'v' => $table.'_v'
                );
                if ($write_log) {
                    file_put_contents($log, "> Verknüpfte Tabellen sichern\r\n", FILE_APPEND);
                }
                foreach ($tables as $key => $table) {
                    if (!$db->tableExists($table)) {
                        continue;
                    }
                    if ($write_log) {
                        file_put_contents($log, ">> $table\r\n", FILE_APPEND);
                    }
                    switch ($key) {
                        case 'newsletter_light':
                            $where = 'abonnent_id = :id';
                            break;
                        case 'v':
                            $where = 'id = :id';
                            break;
                        default:
                            $where = 'page_id = :id';
                    }
                    $db->select(array(
                        'table' => $table,
                        'fields' => '*',
                        'where' => $where,
                        'bind' => array(
                            'id' => $page->field['id']
                        )
                    ));
                    while ($db->nextRecord()) {
                        $s = serialize($db->Record);
                        $file = $dir.'db/'.$table;
                        file_put_contents($file, strlen($s)."\n".$s, FILE_APPEND);
                    }
                }
 
                // Alle Verweise sichern
                if (!$target_dir && $lang_page) {
                    if ($write_log) {
                        file_put_contents($log, "> Verweise sichern\r\n", FILE_APPEND);
                    }
                    foreach ($lang_page->getLinks() as $link) {
                        try {
                            $link_site = new Site($link['dest_site'], $link['dest_lang']);
                            $link_page = $link_site->getPage($link['dest_id'], $params);
                            if ($link_page) {
                                $link_page->download(false, $dir, false);
 
                                // Die Elternseiten müssen auch gesichert werden
                                foreach ($link_page->getParents(array(), $params) as $parent) {
                                    $parent->download(false, $dir, false);
                                }
                            }
                        } catch (Exception $e) {
                            // Ignorieren
                        }
                    }
 
                    $db->select(array(
                        'table' => 'egotec_links',
                        'fields' => '*',
                        'where' => "src_site = :site AND src_lang = :lang AND src_id = :id",
                        'bind' => array(
                            'site' => $this->_site->name,
                            'lang' => $lang,
                            'id' => $page->field['id']
                        )
                    ));
                    while ($db->nextRecord()) {
                        $s = serialize($db->Record);
                        $file = $dir.'db/egotec_links';
                        file_put_contents($file, strlen($s)."\n".$s, FILE_APPEND);
                    }
                }
            }
        }
 
        if (!$target_dir) {
            if ($write_log) {
                file_put_contents($log, "Archiv erstellen\r\n", FILE_APPEND);
            }
            // Archiv erstellen
            require_once('Archive/Tar.php');
            $cwd = getcwd();
            chdir($dir);
            $tmp = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'download');
            $zip = new Archive_Tar($tmp, 'gz');
            $zip->add('./');
            chdir($cwd);
            Ego_System::deldir($dir);
 
            if ($write_log) {
                file_put_contents($log, "Archiv ausgeben\r\n", FILE_APPEND);
            }
            require_once('base/Ego_Output.php');
            $output = new Ego_Output($tmp);
            $date = date('Ymd-His');
            $output->setName('page_'.$this->_site->name.'.'.str_replace(' ', '_', $this->field['name']).'.'.$date.'.tar.gz');
            $output->setTemporary(true);
            $output->download();
        }
    }
 
    public function export() {
        if ($this->field['type'] == 'multimedia/category') {
            $dir = $GLOBALS['egotec_conf']['tmp_dir'];
            $name = 'export'.md5(microtime());
            $folder = $name.DIRECTORY_SEPARATOR
                .urldecode(Ego_System::encode_path(trim($this->field['name']))).DIRECTORY_SEPARATOR;
            $file = $name.'.tar.gz';
            $this->exportArchive($this, $dir.$folder);
 
            // Archiv erstellen
            require_once('Archive/Tar.php');
            $cwd = getcwd();
            chdir($dir);
            $zip = new Archive_Tar($file, 'gz');
            $zip->_separator = ',';
            $zip->createModify(rtrim($folder, DIRECTORY_SEPARATOR), '', $name);
            chdir($cwd);
            Ego_System::deldir($dir.$name);
            return $dir.$file;
        }
        return null;
    }
 
    private function exportArchive($page, $path) {
        Ego_System::mkdir($path);
        foreach ($page->getChildren() as $child) {
            $name = urldecode(Ego_System::encode_path(trim($child->field['name'])));
            if ($child->field['type'] == 'multimedia/category') {
                $this->exportArchive($child, $path.$name.DIRECTORY_SEPARATOR);
            } elseif (in_array($child->field['type'], array('multimedia/file', 'multimedia/image'))) {
                $dir = $GLOBALS['egotec_conf']['var_dir'].
                    'media'.DIRECTORY_SEPARATOR.$this->_site->name.DIRECTORY_SEPARATOR;
                $file = $child->getMediaFilename();
                if ($child->extra['image_type']) {
                    $name .= '.'.$child->extra['image_type'];
                }
                Ego_System::copy($dir.$file, $path.$name);
            }
        }
    }
 
    public function frontendAdmin() {
        if (!$this->frontendActive) {
            $this->frontendActive = true; // Nur einmal umwandeln
            $GLOBALS['frontend_admin'] = true;
            unset($GLOBALS['admin_area']);
            if (!$_SESSION['login']['live_preview']) {
                $_REQUEST['preview'] = $_REQUEST['nonactive'] = 1; // showdeleted wird nicht benötigt
            } else {
                unset($_REQUEST['preview'], $_REQUEST['nonactive']);
            }
 
            // In der Frontend Administration werden auch inaktive Seiten angezeigt
            $this->_site->setOnlyActive(!$_REQUEST['preview']);
 
            $lock = $this->lock();
            if (!$lock) {
                $settings = $this->getEditFieldSettings();
 
                if (!empty($this->conf['noneditable'])) {
                    // Diese Elemente dürfen in der Frontend Administration nicht bearbeitet werden
                    $settings = array_diff_key($settings, array_flip(explode(',', $this->conf['noneditable'])));
                }
 
                // Der Inhalt (field.content) wird automatisch in einen Editor umgewandelt
                $this->createEditField('content', $settings['content']);
            } elseif ($GLOBALS['smarty']) {
                // Die Seite ist gesperrt und kann nicht bearbeitet werden
                $GLOBALS['smarty']->assign('inlineedit_lock', true);
            }
        }
    }
 
    public function getEditFieldSettings($name = '') {
        // Typ der Kurzbeschreibung bestimmen
        $short_type = !$this->_site->admin['editor']['short'] && !$GLOBALS['egotec_conf']['editor']['short']
            ? 'text' : 'content';
 
        // Für Titel und Kurzbeschreibung kein HTML zulassen
        $plaintext = (bool) $this->_site->admin['editor']['plaintext'];
 
        // Konfigurationen zusammenführen
        $settings = array(
            'name' => array(
                'field' => true,
                'title' => $GLOBALS['auth']->translate('Name'),
                'dir' => 'right',
                'type' => 'text',
                'perm' => 'extra_information',
                'mandatory' => true,
                'readonly' => true,
                'plaintext' => true
            ),
            'title' => array(
                'field' => true,
                'title' => $GLOBALS['auth']->translate('Titel'),
                'dir' => 'right',
                'type' => 'text',
                'perm' => 'extra_information',
                'readonly' => true,
                'plaintext' => $plaintext
            ),
            'short' => array(
                'field' => true,
                'title' => $GLOBALS['auth']->translate('Kurzbeschreibung'),
                'dir' => 'right',
                'type' => $short_type,
                'perm' => 'extra_information',
                'plaintext' => $plaintext && $short_type == 'text'
            ),
            'content' => array(
                'field' => true,
                'title' => $GLOBALS['auth']->translate('Inhalt'),
                'dir' => 'right',
                'type' => 'editor'
            )
        );
        if (!empty($this->conf['fields'])) {
            $settings = array_replace_recursive($settings, $this->conf['fields']);
        }
 
        if ($name) {
            // Nur ein bestimmtes Feld zurückliefern
            if (isset($settings[$name])) {
                return $settings[$name];
            }
            return null;
        }
        return $settings;
    }
 
    public function createEditField($name, $setting = array(), $empty = false, $orient = '', $index = 0, $block = '', $replace = false) {
        $field = $setting['field'] ? 'field' : 'extra';
 
        // Sicherstellen, dass ein editierbares Feld nur einmal umgewandelt wird
        if (isset($this->editFields[$field][$name])) {
            return $this->editFields[$field][$name];
        }
 
        // Standardwert aus einer Variablen beziehen
        if (isset($setting['default']) && strpos($setting['default'], '@') === 0) {
            $parts = explode('.', substr($setting['default'], 1), 2);
            $parts[1] = str_replace(array('@orient', '@index', '@block'), array($orient, $index, $block), $parts[1]);
            $setting['default'] = strip_tags((string) Ego_System::getAssocValue($this->{$parts[0]}, $parts[1]));
        }
 
        // Standard Parameter aus der Konfiguration übernehmen, wenn diese nicht direkt übergeben werden
        if (is_array($this->conf['values'][$orient][$setting['type']])) {
            foreach ($this->conf['values'][$orient][$setting['type']] as $param => $value) {
                if (!isset($setting[$param])) {
                    $setting[$param] = $value;
                }
            }
        }
 
        // Titel muss immer gesetzt sein
        if (!isset($setting['title'])) {
            $setting['title'] = $setting['var'];
        }
 
        // Platzhalter immer setzen
        if (!isset($setting['placeholder'])) {
            $setting['placeholder'] = $setting['title'];
        }
 
        $edit_field = function() use ($field, $name, $setting, $empty, $orient, $index, $block, $replace) {
            $this_value = $setting['no_auto'] && !empty($setting['value'])
                ? $setting['value']
                : Ego_System::getAssocValue($this->{$field}, $name);
            if ($field == 'extra' || $this_value !== null) {
                $frontend_admin = $GLOBALS['frontend_admin'] && $this->conf['orients'][$orient]['disabled'] !== true && $this->isCurrentPage();
                $title = $setting['title'] ? $GLOBALS['auth']->translate($setting['title']) : $setting['var'];
                $dir = $setting['dir'] ? $setting['dir'] : 'right';
 
                $type = $setting['type'];
                if ($setting['type'] == 'media') {
                    // "media" Element automatisch auf "image" oder "video" stellen
                    $type = Ego_System::getAssocValue($this->{$field}, "{$name}_type");
                    if (!$type) {
                        // Standardmäßig wird "image" verwendet
                        $type = 'image';
                    }
                }
 
                // Wert ist gekoppelt
                if (strpos($setting['var'], '=') === 0) {
                    [$field, $name] = explode('.', substr($setting['var'], 1), 2);
                }
 
                // Gesetzten Wert ermitteln
                if (($empty || $replace) && isset($setting['initial'])) {
                    // Startwert verwenden
                    $edit_value = $setting['initial'];
                } elseif ($empty) {
                    $edit_value = '';
 
                    // Standardwert verwenden
                    if (!empty($this->conf['blocks'][$block]['default'][$orient])) {
                        $sub_name = implode('.', array_slice(explode('.', $name), 3));
                        if (($default_value = Ego_System::getAssocValue($this->conf['blocks'][$block]['default'][$orient], $sub_name)) !== null) {
                            $edit_value = $default_value;
                        }
                    }
                } else {
                    $edit_value = $this_value;
                }
 
                // Verwendetes Layout ermitteln
                $layout = $this->extra['_layout'];
                if (empty($layout)) {
                    $layout = $this->conf['default_layout']; // Standard Layout verwenden
                }
 
                // Standardblöcke haben immer einen Standardwert
                if (
                    !$setting['default']
                    && !$setting['optional']
                    && !empty($this->conf['layouts'][$layout]['blocks'][$orient]['default'])
                    && in_array($block, explode(',', $this->conf['layouts'][$layout]['blocks'][$orient]['default']))
                    && !in_array($type, array('image', 'media', 'video', 'audio', 'table'))
                ) {
                    $setting['default'] = $title;
                }
 
                if (($empty || ($replace && !$GLOBALS['__egotec_edit_do_save'])) && $frontend_admin && $edit_value == '' && in_array($type, array('text', 'minimal', 'content', 'editor', 'link'))) {
                    // Leere Text Felder vorbelegen
                    if ($type == 'link') {
                        // Bei einem "link" Element muss auch der Linktext vorbelegt werden
                        $edit_value = $setting['default'] ?? '';
                        Ego_System::setAssocValue($this->{$field}, "{$name}_text", $title);
                    } else {
                        $edit_value = $setting['default'];
                    }
                }
 
                if ($frontend_admin && in_array($type, array('image', 'video', 'audio'))) {
                    $type_class = "egotec_type_{$type}";
                    if (!empty($setting['attr']['class'])) {
                        $setting['attr']['_class'] = $setting['attr']['class'];
                    }
                    $setting['attr']['class'] = "egotec_media {$type_class}";
                }
 
                switch ($type) {
                    case 'editor':
                    case 'content':
                    case 'text':
                    case 'minimal':
                        if (!$frontend_admin) {
                            // Text Elemente unterstützen auch den "attr" Parameter
                            if (isset($setting['attr'])) {
                                $tag_name = $type == 'text' ? 'span' : 'div';
                                $wrapper = '<' . $tag_name;
                                foreach ($setting['attr'] as $attr => $value) {
                                    $wrapper .= ' ' . $attr . '="' . str_replace('"', '\"', $value) . '"';
                                }
                                $wrapper .= '>' . $edit_value . '</' . $tag_name . '>';
                                $edit_value = $wrapper;
                            }
                        }
                        break;
 
                    case 'video':
                    case 'audio':
                        // "video" Elemente erzeugen ein VIDEO Element
                        // "audio" Elemente erzeugen ein AUDIO Element
 
                        // Für die Erzeugung die Smarty video Funktion verwenden
                        require_once 'smarty/plugins/function.video.php';
                        $edit_value = smarty_function_video(array_replace_recursive(array(
                            'src' => $edit_value,
                            'poster' => Ego_System::getAssocValue($this->{$field}, "{$name}_poster"),
                            'alt' => Ego_System::getAssocValue($this->{$field}, "{$name}_alt"),
                            'controls' => $setting['attr']['controls'] ?? Ego_System::getAssocValue($this->{$field}, "{$name}_controls"),
                            'autoplay' => $setting['attr']['autoplay'] ?? Ego_System::getAssocValue($this->{$field}, "{$name}_autoplay"),
                            'loop' => $setting['attr']['loop'] ?? Ego_System::getAssocValue($this->{$field}, "{$name}_loop"),
                            'muted' => $setting['attr']['muted'] ?? Ego_System::getAssocValue($this->{$field}, "{$name}_muted"),
                            'preload' => Ego_System::getAssocValue($this->{$field}, "{$name}_preload"),
                            'fallback' => $frontend_admin,
                            'audio' => $type == 'audio'
                        ), $setting), $GLOBALS['smarty']);
 
                        if (empty($edit_value)) {
                            $setting['empty'] = true;
                        }
 
                        break;
 
                    case 'image':
                        // "image" Elemente erzeugen ein PICTURE Element
                        if (!$frontend_admin && empty($edit_value) && !$setting['default']) {
                            // Im Frontend keine leeren Bilder anzeigen
                            return '';
                        }
 
                        // Attribute festlegen
                        foreach (array('alt', 'title') as $attr) {
                            if (!isset($setting['attr'][$attr])) {
                                if (($attr_value = Ego_System::getAssocValue($this->{$field}, "{$name}_{$attr}")) !== null) {
                                    $setting['attr'][$attr] = $attr_value;
                                }
                            }
                        }
                        if (isset($setting['attr']['class'])) {
                            $setting['attr']['class'] .= ' ' . Ego_System::getAssocValue($this->{$field}, "{$name}_class");
                            $setting['attr']['class'] = trim($setting['attr']['class']);
                        } elseif (($attr_value = Ego_System::getAssocValue($this->{$field}, "{$name}_class")) !== null) {
                            $setting['attr']['class'] = $attr_value;
                        }
 
                        // Verlinkung erkennen
                        if ($image_href = Ego_System::getAssocValue($this->{$field}, "{$name}_href")) {
                            $setting['attr']['data-href'] = $image_href;
                            $setting['attr']['data-target'] = Ego_System::getAssocValue($this->{$field}, "{$name}_target");
                        }
 
                        // URLs für die unterschiedlichen Viewports
                        $viewports = Ego_System::getAssocValue($this->{$field}, "{$name}_viewports");
 
                        // Für die Erzeugung die Smarty picture Funktion verwenden
                        require_once('smarty/plugins/function.picture.php');
                        $edit_value = smarty_function_picture(array_replace_recursive(array(
                            'src' => $edit_value,
                            'href' => !$setting['url'] ? $image_href : '',
                            'target' => !$setting['url'] ? Ego_System::getAssocValue($this->{$field}, "{$name}_target") : '',
                            'fallback' => $frontend_admin
                        ), $setting, [
                            'viewports' => $viewports
                        ]), $GLOBALS['smarty']);
                        if (empty($edit_value)) {
                            $setting['empty'] = true;
                        }
                        break;
 
                    case 'file':
                        // "file" Elemente erzeugen ein IFRAME Element
                        if (!$frontend_admin && empty($edit_value) && !$setting['default']) {
                            // Im Frontend keine leeren Dateien anzeigen
                            return '';
                        }
 
                        // Platzhalter URL
                        $default = $GLOBALS['egotec_conf']['url_dir'] . 'bin/page/blocks/file.html';
 
                        // Proportionen (Standard: 16:9)
                        $ratio = str_replace(':', '/', $setting['ratio'] ?? '16:9');
 
                        $setting['misc'] = array_merge([
                            'src' => $default,
                            'style' => 'width: 100%; height: auto; aspect-ratio: ' . $ratio,
                            'allowfullscreen' => '',
                            'loading' => 'lazy'
                        ], $setting['attr'] ?? []);
 
                        // Attribute werden nur für das IFRAME Element gesetzt
                        if (isset($setting['attr'])) {
                            unset($setting['attr']);
                        }
 
                        $iframe = '<iframe';
                        foreach ($setting['misc'] as $attr => $value) {
                            if ($attr == 'src') {
                                // Anzeige im Dokumentenbetrachter (nur für interne URLs)
                                if (
                                    Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'document')
                                    && !empty($GLOBALS['egotec_conf']['document']['blocks_enabled'])
                                    && !empty($edit_value)
                                    && strpos(ltrim($edit_value, '/'), 'index.php') === 0
                                ) {
                                    $info = array_filter(Ego_System::getUrlParams($edit_value), function($key) {
                                        return in_array($key, ['site', 'lang', 'id', 'pool', 'dir']);
                                    }, ARRAY_FILTER_USE_KEY);
                                    $edit_value = $GLOBALS['egotec_conf']['url_dir'] . 'bin/document/editor.php?' . http_build_query($info);
                                }
 
                                $value = $edit_value ?: $value;
                            }
                            $iframe .= ' ' . $attr . ($value === '' ? '' : '="' . $value . '"');
                        }
                        $iframe .= '></iframe>';
 
                        $edit_value = $iframe;
                        if ($frontend_admin) {
                            $edit_value = '<div>' . $edit_value . '</div>';
                        }
 
                        // NULL Werte nicht übernehmen
                        $setting['misc'] = array_filter($setting['misc'], function($value) {
                            return $value !== null;
                        });
                        break;
 
                    case 'link':
                        // "link" Elemente erzeugen ein A Element
                        if (!$frontend_admin && empty($edit_value)) {
                            // Im Frontend keine leeren Links anzeigen
                            return '';
                        }
 
                        // Attribute festlegen
                        $default = '<a href=""';
                        $a = '<a href="' . $edit_value . '"';
                        if (!is_array($setting['attr'])) {
                            $setting['attr'] = array();
                        }
                        foreach (array('class', 'title', 'target') as $attr) {
                            if (!isset($setting['attr'][$attr])) {
                                $setting['attr'][$attr] = Ego_System::getAssocValue($this->{$field}, "{$name}_{$attr}");
                            } elseif ($attr == 'class') {
                                $setting['attr']['class'] .= ' ' . Ego_System::getAssocValue($this->{$field}, "{$name}_class");
                                $setting['attr']['class'] = trim($setting['attr']['class']);
                            }
                        }
                        foreach ($setting['attr'] as $attr => $value) {
                            if ($attr != 'href' && $value != '') {
                                if ($attr != 'target') {
                                    $default .= ' ' . $attr . '="' . str_replace('"', '\"', $value) . '"';
                                }
                                $a .= ' ' . $attr . '="' . str_replace('"', '\"', $value) . '"';
                            }
                        }
                        $default .= '>' . ($setting['default'] ? $setting['default'] : $title) . '</a>';
                        $a .= '>' . Ego_System::getAssocValue($this->{$field}, "{$name}_text") . '</a>';
                        $setting['default'] = $default;
                        $edit_value = empty($edit_value) ? $default : $a;
                        break;
 
                    case 'table':
                        // "table" Elemente erzeugen ein TABLE Element
                        if (!$frontend_admin && empty($edit_value)) {
                            // Im Frontend keine leeren Tabellen anzeigen
                            return '';
                        }
 
                        if (strpos($this->field['type'], 'e2e/') !== 0) { // "e2e" Seitentypen ignorieren
                            // Zeilen und Spalten können standardmäßig bearbeitet werden
                            foreach (['rows_edit', 'cols_edit', 'cols_size'] as $key) {
                                if (!isset($setting[$key]) || !empty($setting[$key])) {
                                    $setting[$key] = true;
                                }
                            }
 
                            $create = function ($name1, $name2, $rows, $cols, $contents = '') {
                                $contents = explode('|', is_string($contents) ? $contents : '');
                                $html = "<{$name1}>";
                                for ($r = 0; $r < $rows; $r++) {
                                    $html .= '<tr>';
                                    for ($c = 0; $c < $cols; $c++) {
                                        $content = isset($contents[$c]) && trim($contents[$c]) != ''
                                            ? $GLOBALS['auth']->translate(trim($contents[$c]))
                                            : '<br>'; // muss gesetzt werden, damit man die Spalte beschreiben kann
                                        $html .= "<{$name2}>{$content}</{$name2}>";
                                    }
                                    $html .= '</tr>';
                                }
                                $html .= "</{$name1}>";
                                return $html;
                            };
 
                            if (!empty($setting['default'])) {
                                // Übergebene Standard Tabelle verwenden
                                $table = trim($setting['default']);
                            } else {
                                // Standard Tabelle erzuegen
                                $rows = $setting['rows'] ? (int)$setting['rows'] : 2;
                                $cols = $setting['cols'] ? (int)$setting['cols'] : 2;
 
                                $table = '<table';
                                if (is_array($setting['attr'])) {
                                    // Attribute setzen
                                    foreach ($setting['attr'] as $attr => $value) {
                                        $table .= ' ' . $attr . '="' . str_replace('"', '\"', $value) . '"';
                                    }
                                }
                                $table .= '>';
 
                                $table .= ($setting['thead'] ? $create('thead', 'th', 1, $cols, $setting['thead']) : '')
                                    . $create('tbody', 'td', $rows, $cols)
                                    . ($setting['tfoot'] ? $create('tfoot', 'td', 1, $cols, $setting['tfoot']) : '')
                                    . '</table>';
 
                                // Standard Tabelle verwenden
                                $setting['default'] = $table;
                            }
 
                            if (empty($edit_value)) {
                                $edit_value = $table;
                            } else {
                                // Falls sich die Attribute geändert haben, muss die Tabelle aktualisiert werden
                                require_once('base/Ego_DomQuery.php');
                                $dom = new Ego_DomQuery($edit_value);
                                $table = $dom->doc->firstChild;
                                $changed = false;
                                if ($table->hasAttributes()) {
                                    foreach ($table->attributes as $attribute) {
                                        if (
                                            !is_array($setting['attr'])
                                            || empty($setting['attr'])
                                            || !in_array($table->nodeName, array_keys($setting['attr']))
                                        ) {
                                            // Attribut entfernen
                                            $table->removeAttribute($attribute->nodeName);
                                            $changed = true;
                                        }
                                    }
                                }
                                if (is_array($setting['attr'])) {
                                    foreach ($setting['attr'] as $attr => $value) {
                                        if (!$table->hasAttribute($attr) || $table->getAttribute($attr) != $value) {
                                            // Neues oder geändertes Attribut hinzufügen
                                            $table->setAttribute($attr, $value);
                                            $changed = true;
                                        }
                                    }
                                }
                                if ($changed) {
                                    $edit_value = $dom->getHTML();
                                }
                            }
                        }
                        break;
 
                    case 'value':
                    case 'date':
                        // "value", "date" Elemente geben nur den Wert zurück
                        $value = Ego_System::getAssocValue($this->{$field}, $name);
 
                        $get_value = function($value, $select) use ($type, $setting) {
                            if (empty($value)) {
                                $value = !empty($select['default'])
                                    ? $select['default']
                                    : (!empty($setting['default'])
                                        ? $setting['default']
                                        : '');
 
                                // Der Standardwert für "date" kann ein relatives Datum sein
                                if ($type == 'date' && preg_match('/^<%(.*?)>$/', $value, $match)) {
                                    $value = $match[1];
                                }
                            }
                            if (!empty($select['format']) && !empty($value)) {
                                $value = date($select['format'], strtotime($value));
                            }
                            if (!empty($select['value'])) {
                                $value = str_replace('<%>', $value, $select['value']);
                            }
                            return $value;
                        };
 
                        // Zunächst die Einstellungen des Bedienelements anwenden
                        if (
                            !empty($orient)
                            && (($block_name = $block) || ($block_name = $this->extra['_blocks'][$orient][$index]))
                            && ($controls = $this->getBlockControls($block_name))
                        ) {
                            $value_name = ltrim(strrchr($name, '.'), '.');
                            foreach ($controls as $select) {
                                if ($select['name'] == $value_name) {
                                    $value = $get_value($value, $select);
                                }
                            }
                        }
 
                        // Dann die direkten Einstellungen anwenden
                        $value = $get_value($value, $setting);
 
                        return $value;
 
                    case 'code':
                        if (empty($edit_value)) {
                            if (!$frontend_admin) {
                                // Im Frontend keinen leeren Code anzeigen
                                return '';
                            } else {
                                $edit_value = $setting['default'] ?? $title;
                            }
                        }
 
                        $languages = $setting['languages'] ?? $this->conf['code']['languages'] ?? array();
                        if (!is_array($languages)) {
                            $languages_array = explode(',', $languages);
                            $languages = array();
                            foreach ($languages_array as $language) {
                                $languages[$language] = $language;
                            }
                        }
                        asort($languages, SORT_NATURAL);
                        $first_language = null;
                        foreach ($languages as $value => $text) {
                            $first_language = $value;
                            break;
                        }
 
                        // Ausgewählte Sprache bestimmen
                        $mode = Ego_System::getAssocValue($this->extra, $name . '_mode')
                            ?? $setting['mode']
                            ?? $this->conf['code']['mode']
                            ?? $first_language
                            ?? 'HTML';
 
                        $smarty = Ego_Smarty::createFrontend($this->getSite(), array(
                            'id' => 'code-' . md5($name),
                            'name' => $name,
                            'value' => $edit_value,
                            'theme' => $setting['theme'] ?? $this->conf['code']['theme'] ?? 'monokai',
                            'mode' => mb_strtolower($mode),
                            'selected_mode' => $mode,
                            'label' => $setting['label'] ?? $languages[$mode] ?? $mode,
                            'min' => $setting['min'] ?? $this->conf['code']['min'] ?? 3,
                            'max' => $setting['max'] ?? $this->conf['code']['max'] ?? 20,
                            'languages' => $languages
                        ));
                        $edit_value = $smarty->fetch($GLOBALS['egotec_conf']['lib_dir'] . 'page/t/input/code.tpl');
                }
 
                $label_callback = function($callback) use ($setting, $orient, $index, $block) {
                    if ($setting['var'] == 'label') {
                        foreach (array('required', 'optional') as $display_type) {
                            if (
                                $this->conf['form'][$display_type]
                                && strpos($block, 'input_') === 0
                                && $this->extra['_contents'][$orient][$index]['extra'][$display_type]
                            ) {
                                $callback($display_type);
                            }
                        }
                    }
                };
 
                // Standardwert für required/optional Eingabefelder für Labels in Formular Blöcken
                $label_callback(function($display_type) use (&$edit_value, &$setting, $title) {
                    if (trim($edit_value) == '') {
                        $edit_value = $setting['default'] = $setting['default'] ?? $title;
                    }
                });
 
                // Automatisches Befüllen
                $autofill = $this->conf['autofill'];
                if (isset($this->conf['blocks'][$block]['autofill'])) {
                    $autofill = $this->conf['blocks'][$block]['autofill'];
                }
                if (isset($setting['autofill'])) {
                    $autofill = $setting['autofill'];
                }
 
                // Nur in der Frontend Administration und nur für diese Seite ein editierbares Element verwenden
                if ($frontend_admin) {
                    $escape = function($s) {
                        return htmlspecialchars(
                            preg_replace('/\s+/', ' ', $s),
                            ENT_QUOTES,
                            'UTF-8'
                        );
                    };
 
                    // Booleansche Werte müssen als String übergeben werden
                    foreach (array('toolbar', 'menubar') as $key) {
                        if (isset($setting[$key]) && is_bool($setting[$key])) {
                            $setting[$key] = $setting[$key] === true ? 'true' : 'false';
                        }
                    }
 
                    // Zusätzliche Attribute setzen
                    $additional_attributes = array();
                    if (!empty($setting['attr'])) {
                        foreach ($setting['attr'] as $attr => $value) {
                            if (
                                $attr == '_class'
                                // Bestimmte Elemente setzen die Attribute für das implizite HTML
                                || in_array($setting['type'], array('link', 'table'))
                            ) {
                                continue;
                            }
 
                            if ($attr == 'class' && isset($setting['attr']['_class'])) {
                                $setting['attr']['class'] = implode(' ', array_unique(array_merge(explode(' ', $value), explode(' ', $setting['attr']['_class']))));
                                unset($setting['attr']['_class']);
                            }
 
                            // Klassen, die nur auf dem Bild gesetzt sein sollen nicht auf den Container setzen
                            if ($attr === 'class' && in_array($setting['type'], ['image', 'media'])) {
                                $classes = explode(' ', $value);
                                $image_classes = explode(' ', Ego_System::getAssocValue($this->{$field}, "{$name}_class"));
                                $div_classes = [];
 
                                foreach ($classes as $class) {
                                    if (!in_array($class, $image_classes)) {
                                        $div_classes[] = $class;
                                    }
                                }
 
                                $value = implode(' ', $div_classes);
                            }
 
                            $additional_attributes[] = $attr . '="' . $escape($value) . '"';
                        }
                    }
 
                    $tag_name = $setting['tag_name'] ?? 'div';
                    $edit_value = '<' . $tag_name
                        . ($setting['field'] ? ' data-edit-field="' . $name . '"' : ' data-edit-extra="' . $name . '"')
                        . ' data-edit-type="' . $setting['type'] . '"'
                        . ($setting['default'] ? ' data-edit-default="' . $escape($GLOBALS['auth']->translate($setting['default'])) . '"' : '')
                        . ($setting['perm'] && !$this->hasRights(explode(',', $setting['perm'])) ? ' data-edit-locked="true"' : '')
                        . ($setting['style'] ? ' style="' . $setting['style'] . '"' : '') // @deprecated
                        . ($setting['mandatory'] ? ' data-edit-mandatory="true"' : '')
                        . ($setting['readonly'] ? ' data-edit-readonly="true"' : '')
                        . ($setting['no_auto'] ? ' data-edit-no-auto="true"' : '')
                        . ($setting['rows_edit'] ? ' data-edit-rows="true"' : '')
                        . ($setting['cols_edit'] ? ' data-edit-cols="true"' : '')
                        . ($setting['cols_size'] ? ' data-edit-cols-size="true"' : '')
                        . ($setting['maxlength'] ? ' data-edit-maxlength="' . $setting['maxlength'] . '"' : '')
                        . ($setting['srcset'] ? ' data-edit-srcset="' . $setting['srcset'] . '"' : '')
                        . ($setting['empty'] ? ' data-edit-empty="true"' : '')
                        . ($setting['href'] === false ? ' data-edit-href="false"' : '')
                        . ($setting['optional'] ? ' data-edit-optional="true"' : '')
                        . ($setting['plaintext'] ? ' data-edit-plaintext="true"' : '')
                        . ($setting['root'] ? ' data-edit-root="true"' : '')
                        . ($setting['unsafe'] ? ' data-edit-unsafe="true"' : '')
                        . ($setting['hooks'] ? ' data-edit-hooks="' . $setting['hooks'] . '"' : '')
                        . ($setting['plugins'] ? ' data-edit-plugins="' . $setting['plugins'] . '"' : '')
                        . ($setting['toolbar'] ? ' data-edit-toolbar="' . $setting['toolbar'] . '"' : '')
                        . ($setting['menubar'] ? ' data-edit-menubar="' . $setting['menubar'] . '"' : '')
                        . ($setting['paste_tags'] ? ' data-edit-paste-tags="' . $setting['paste_tags'] . '"' : '')
                        . ($setting['paste_attrs'] ? ' data-edit-paste-attrs="' . $setting['paste_attrs'] . '"' : '')
                        . ($setting['placeholder'] ? ' data-edit-placeholder="' . $escape($GLOBALS['auth']->translate($setting['placeholder'])) . '"' : '')
                        . ($setting['edit'] !== false ? ' data-edit-media="' . $escape(json_encode($setting['edit'] ?? true, JSON_FORCE_OBJECT)) . '"' : '')
                        . (!empty($setting['attr']) ? ' data-edit-attr="' . $escape(json_encode($setting['attr'], JSON_FORCE_OBJECT)) . '"' : '')
                        . (!empty($setting['misc']) ? ' data-edit-misc="' . $escape(json_encode($setting['misc'], JSON_FORCE_OBJECT)) . '"' : '')
                        . (!empty($autofill) ? ' data-edit-autofill="' . $escape(json_encode($autofill, JSON_FORCE_OBJECT)) . '"' : '')
                        . ((!empty($setting['caption']) && !empty($setting['url'])) || !empty($setting['no_link']) ? ' data-edit-hide-link="1"' : '')
                        . implode(' ', $additional_attributes)
                        . '>' . $edit_value . '</' . $tag_name . '>';
                    Ego_System::setAssocValue($this->{$field}, $name, $edit_value);
                }
 
                // Darstellung für required/optional Eingabefelder für Labels in Formular Blöcken
                $label_callback(function($display_type) use (&$edit_value) {
                    $edit_value = $GLOBALS['smarty']->fetch('string:' . str_replace('<%>', $edit_value, $this->conf['form'][$display_type]));
                });
 
                if (in_array($type, array('video', 'audio', 'image', 'media'))) {
                    // Bildbeschreibung hinzufügen (im Frontend nur, wenn der Wert nicht leer ist)
                    $caption = $this->conf['caption'];
                    if (isset($this->conf['blocks'][$block]['caption'])) {
                        $caption = $this->conf['blocks'][$block]['caption'];
                    }
                    if (isset($setting['caption'])) {
                        $caption = $setting['caption'];
                    }
 
                    if ($caption) {
                        $caption_autofill = !empty($autofill['caption']['readonly']);
                        $caption_value = '';
 
                        // Bildbeschreibung automatisch ermitteln
                        if ($caption_autofill && !empty($this_value) && ($media_page = Ego_System::urltopage($this_value, ['inactive' => true, 'only_active' => false]))) {
                            $result = $media_page->getAutoFill($autofill, Ego_System::getUrlParams($this_value));
                            $caption_value = (string) $result['caption']['value'];
                        }
 
                        if ($frontend_admin) {
                            // Für die Erzeugung die Smarty value Funktion verwenden
                            require_once('smarty/plugins/function.value.php');
                            $var = substr(strrchr($name, '.'), 1);
                            $caption_value = smarty_function_value(array(
                                'var' => "{$var}_caption",
                                'type' => 'minimal',
                                'title' => $setting['type'] == 'image'
                                    ? $GLOBALS['auth']->translate('Bildbeschreibung')
                                    : $GLOBALS['auth']->translate('Beschreibung'),
                                'orient' => $orient,
                                'index' => $index,
                                'readonly' => $caption_autofill,
                                'no_auto' => $caption_autofill,
                                'value' => $caption_value
                            ), $GLOBALS['smarty']);
                        } elseif (!$caption_autofill) {
                            $caption_value = Ego_System::getAssocValue($this->{$field}, "{$name}_caption");
                        }
                        if ($caption_value != '') {
                            $edit_value = str_replace(array('<%>', '<#>'), array($edit_value, $caption_value), $caption);
                        }
                    }
                }
 
                if ($setting['tag_name'] && !$frontend_admin && $edit_value != '') {
                    // Wrapper für das Element hinzufügen (im Frontend nur, wenn der Wert nicht leer ist)
                    $edit_value = "<{$setting['tag_name']}>$edit_value</{$setting['tag_name']}>";
                }
 
                if ($setting['wrapper'] && ($frontend_admin || $edit_value != '')) {
                    // Wrapper für das Element hinzufügen (im Frontend nur, wenn der Wert nicht leer ist)
                    $edit_value = str_replace('<%>', $edit_value, $setting['wrapper']);
                }
 
                if ($setting['url']) {
                    // URL platzieren
                    $href = Ego_System::getAssocValue($this->{$field}, "{$name}_href");
                    $target = Ego_System::getAssocValue($this->{$field}, "{$name}_target");
                    if ($frontend_admin || !$href) {
                        // Keine Aktion ausführen
                        $href = 'javascript:void(0)';
                    }
 
                    require_once('base/Ego_DomQuery.php');
                    $dom = new Ego_DomQuery($edit_value);
                    $links = $dom->query($setting['url']);
                    foreach ($links as $link) {
                        $link->setAttribute('href', $href);
                        if ($target) {
                            $link->setAttribute('target', $target);
                        }
                    }
                    $edit_value = $dom->getHTML();
                }
 
                return $edit_value;
            }
            return null;
        };
 
        return $this->editFields[$field][$name] = $edit_field();
    }
 
    public function updateUrls($verbose = false, $domain = null, $force_recursive = false, $called_recursive = false) {
        if (
            $GLOBALS['egotec_conf']['rewrite_engine'] != 'url' // Nur wenn die richtige RewriteEngine eingestellt ist
            || (
                $_SERVER['HTTP_X_SOAP_CALL'] == 'Replication' // Erfolgt der Aufruf über den Liveabgleich
                && $this->getSite()->getCache()->getEternal() // und ist die "ewige" Cache aktiv, werden keine URLs aktualisiert
            )
            || $this->field['deleted'] // Gelöschte Seiten haben keine URLs
            || $this->isReleaseCopy() // Freigabekopien haben keine URLs
            || strpos($this->field['type'], '/occupancy/') // Buchungen der Resourcenverwaltung haben keine URLs
        ) {
            return;
        }
 
        // Bei einer rekursiven URL Generierung sicherstellen, dass die selben Seiten nicht mehrfach berechnet werden
        if (isset($GLOBALS['__page_update_urls_stack']) && in_array($this->getIdentity(), $GLOBALS['__page_update_urls_stack'])) {
            return;
        }
        if (!isset($GLOBALS['__page_update_urls_stack'])) {
            $GLOBALS['__page_update_urls_stack'] = [];
        }
        $GLOBALS['__page_update_urls_stack'][] = $this->getIdentity();
 
        $db = new_db_connection();
 
        $get_current_urls = function() use ($db) {
            $db->select(array(
                'table' => 'egotec_url',
                'fields' => 'site, lang, id, domain, dir, path, canonical',
                'where' => 'site = :site AND lang = :lang AND id = :id AND canonical = 1',
                'bind' => array(
                    'site' => $this->_site->name,
                    'lang' => $this->_site->language,
                    'id' => $this->field['id']
                )
            ));
            $urls = array();
            while ($db->nextRecord()) {
                $urls[] = $db->Record;
            }
            return $urls;
        };
 
        $old_urls = $get_current_urls();
 
        // Alle primären und sekundären virtuellen Hosts ermitteln
        $virtual_hosts = $this->_site->getVirtualHosts();
 
        // Bereichs-Domain ermitteln (nur auf einem Liveserver oder Redaktionsserver, wenn es keine Liveserver gibt)
        $area_domain = [];
        $use_area_domain = $GLOBALS['egotec_conf']['liveserver'] || !$this->_site->hasLiveserver();
        if ($use_area_domain) {
            if ($domain) {
                $area_domain = $domain;
            }
            if ($this->extra['area_domain']) {
                // Die eigene Bereichs-Domain wird immer zur primären URL
                array_unshift($area_domain, mb_strtolower($this->extra['area_domain']));
            }
 
            // Keine Vererbung, wenn der Aufruf rekursiv erfolgt oder die Domain(s) bereits übergeben wurde(n)
            if (!$called_recursive && empty($domain)) {
                $ancestors = $this->getAncestors();
                $inherited_domains = [];
                foreach ($ancestors as $ancestor) {
                    if ($ancestor->extra['area_domain']) {
                        $inherited_domains[] = mb_strtolower($ancestor->extra['area_domain']);
                    }
                }
                if (!empty($inherited_domains)) {
                    $inherited_domains = array_reverse($inherited_domains);
                    foreach ($inherited_domains as $inherited_domain) {
                        $area_domain[] = $inherited_domain;
                    }
                }
            }
            if (!empty($area_domain)) {
                for ($i = 0; $i < sizeof($area_domain); $i++) {
                    $area_domain[$i] = rtrim(preg_replace('/^https?:\/\//', '', $area_domain[$i]), '/');
                }
                $virtual_hosts = $area_domain; // Nur die Bereichs-Domains, bzw. übergebenen Domains verwenden
            }
        }
 
        if (!$this->field['inactive'] || $this->isWorkflowCopy()) {
            $now = date('Y-m-d H:i:s');
 
            // Zu verwendende Konfiguration ermitteln
            $conf = $this->_site->getRewriteConf();
 
            // Merken, ob die erste URL (canonical = 1) bereits eingefügt wurde
            $first_url_inserted = 0;
 
            $insert_urls = function($names, $paths, $exists = false) use ($db, $domain, $virtual_hosts, $now, &$first_url_inserted) {
                foreach ($names as $ni => $name) {
                    foreach ($paths as $pi => $path) {
                        $dir = trim($GLOBALS['egotec_conf']['url_dir'] . implode('/', array_filter(array($path['name'], $name))), '/');
 
                        foreach ($virtual_hosts as $vi => $virtual_host) {
                            $this_dir = $dir;
                            // Domains mit /abc übergeben die Erweiterung dem Pfad
                            $virtual_host = rtrim($virtual_host, '/');
                            if ($part = strstr($virtual_host, '/')) {
                                $virtual_host = strstr($virtual_host, '/', true);
                                $this_dir = trim($part . "/{$dir}", '/');
                            }
 
                            $params = array(
                                'site' => $this->_site->name,
                                'lang' => $this->_site->language,
                                'id' => $this->field['id'],
                                'domain' => $virtual_host,
                                'dir' => $this_dir,
                                'path' => (string)$path['id']
                            );
 
                            // Sicherstellen, dass der Pfad einmalig ist (archivierte URLs werden bei der Prüfung ignoriert)
                            $unique_dir = $this_dir;
                            $duplicate_params = $params;
                            unset(
                                $duplicate_params['site'],
                                $duplicate_params['lang'],
                                $duplicate_params['id'],
                                $duplicate_params['path']
                            );
                            $n = 1;
                            while ($this_dir != '') {
                                $duplicate_params['dir'] = $unique_dir;
                                $db->select(array(
                                    'table' => 'egotec_url',
                                    'where' => 'domain = :domain AND dir = :dir',
                                    'bind' => $duplicate_params
                                ));
                                if ($db->nextRecord()) {
                                    if (
                                        $db->Record['site'] == $this->_site->name
                                        && $db->Record['lang'] == $this->_site->language
                                        && $db->Record['id'] == $this->field['id']
                                        && !$db->nextRecord()
                                    ) {
                                        break;
                                    }
                                    if ($db->Record['canonical'] == 0) {
                                        $db->delete(array(
                                            'table' => 'egotec_url',
                                            'where' => 'site = :site AND lang = :lang AND id = :id AND domain = :domain AND dir = :dir AND path = :path AND canonical = 0',
                                            'bind' => array(
                                                'site' => $db->Record['site'],
                                                'lang' => $db->Record['lang'],
                                                'id' => $db->Record['id'],
                                                'domain' => $db->Record['domain'],
                                                'dir' => $db->Record['dir'],
                                                'path' => $db->Record['path']
                                            )
                                        ));
                                    } else {
                                        $unique_dir = $this_dir . '-' . $n++;
                                    }
                                } else {
                                    break;
                                }
                            }
                            $params['dir'] = $unique_dir;
 
                            // Prüfen, ob die URL bereits eingetragen ist
                            if ($exists) {
                                $db->select(array(
                                    'table' => 'egotec_url',
                                    'where' => 'domain = :domain AND dir = :dir AND canonical > 0',
                                    'bind' => array(
                                        'domain' => $params['domain'],
                                        'dir' => $params['dir']
                                    )
                                ));
                                if ($db->nextRecord()) {
                                    // Änderungsdatum aktualisieren, damit diese URL nicht archiviert wird
                                    $db->update(array(
                                        'table' => 'egotec_url',
                                        'where' => 'domain = :domain AND dir = :dir AND canonical > 0',
                                        'bind' => array(
                                            'domain' => $params['domain'],
                                            'dir' => $params['dir']
                                        ),
                                        'set' => array(
                                            'c_date' => $now
                                        )
                                    ));
 
                                    continue;
                                }
                            }
 
                            // Doppelte Einträge vermeiden
                            $db->begin();
                            $db->delete(array(
                                'table' => 'egotec_url',
                                'where' => 'domain = :domain AND dir = :dir',
                                'bind' => array(
                                    'domain' => $params['domain'],
                                    'dir' => $params['dir']
                                )
                            ));
 
                            // Neue kanonische URL einfügen
                            $db->insert(array(
                                'table' => 'egotec_url',
                                'set' => array_merge($params, array(
                                    'canonical' => $first_url_inserted == 0 && $ni == 0 && $vi == 0 ? ($first_url_inserted = 1) : 2,
                                    'c_date' => $now
                                ))
                            ));
                            $db->commit();
                        }
                    }
                }
            };
 
            // Namen und Pfade generieren
            $names = array();
            $paths = array();
 
            // Alle möglichen Namen dieser Seite für die URLs
            if (empty($this->field['url']) || $conf['meta']) {
                if (!$conf['flat']) {
                    // URLs aus allen Pfaden
                    $paths = $this->getPaths(false, true, $use_area_domain);
                }
 
                $names = $this->getUrlNames();
            }
 
            // Die Startseite kennt auch URLs ohne Namen (wird immer zu canonical = 1)
            if ($this->field['id'] == $this->_site->rootId || ($use_area_domain && $this->extra['area_domain'])) {
                array_unshift($names, '');
            }
 
            if (!empty($names)) {
                if (empty($paths)) {
                    // URLs ohne Pfad
                    $paths[] = array(
                        'name' => ''
                    );
                }
 
                $insert_urls($names, $paths);
            }
 
            // Eindeutige Meta URL
            if (!empty($this->field['url'])) {
                $paths = array(array(
                    'name' => ''
                ));
                $space = $conf['space'];
                if (empty($space)) {
                    $space = '+';
                }
                $name = str_replace(' ', $space, $this->field['url']);
                $names = array($name);
 
                $insert_urls($names, $paths, true);
            }
 
            // Permalinks hinzufügen
            $db->delete(array(
                'table' => 'egotec_url',
                'where' => 'site = :site AND lang = :lang AND id = :id AND canonical = 3',
                'bind' => array(
                    'site' => $this->_site->name,
                    'lang' => $this->_site->language,
                    'id' => $this->field['id']
                )
            ));
 
            $db->begin();
            foreach ($virtual_hosts as $vi => $virtual_host) {
                $dir = '';
 
                // Domains mit /abc übergeben die Erweiterung dem Pfad
                $virtual_host = rtrim($virtual_host, '/');
                if ($part = strstr($virtual_host, '/')) {
                    $virtual_host = strstr($virtual_host, '/', true);
                    $dir = ltrim($part . '/', '/');
                }
 
                $db->replace(array(
                    'table' => 'egotec_url',
                    'set' => array(
                        'site' => $this->_site->name,
                        'lang' => $this->_site->language,
                        'id' => $this->field['id'],
                        'domain' => $virtual_host,
                        'dir' => "{$dir}-{$this->field['id']}",
                        'path' => '',
                        'canonical' => 3,
                        'c_date' => $now
                    ),
                    'primary' => [ 'domain', 'dir' ]
                ));
            }
            $db->commit();
 
            // Alle alten URLs archivieren
            $db->update(array(
                'table' => 'egotec_url',
                'where' => 'site = :site AND lang = :lang AND id = :id AND canonical > 0 AND c_date < :c_date',
                'bind' => array(
                    'site' => $this->_site->name,
                    'lang' => $this->_site->language,
                    'id' => $this->field['id'],
                    'c_date' => $now
                ),
                'set' => array(
                    'canonical' => 0
                )
            ));
        }
 
        if ($verbose) {
            Ego_System::flush('.');
        }
 
        // Rekursiv alle Unterseiten aktualisieren
        if (
            $force_recursive
            || (
                $this->field['id'] != $this->_site->rootId // nicht für die Startseite
                && serialize($old_urls) != serialize($get_current_urls()) // und nur, wenn sich die URLs dieser Seite geändert haben
            )
        ) {
            $children = $this->getChildren(array(), array(
                'auth_or' => '1=1',
                'inactive' => true,
                'only_active' => false
            ));
            foreach ($children as $child) {
                $child->updateUrls($verbose, $area_domain, $force_recursive, true); // @TODO Performancegewinn wenn man die bereits berechneten URLs weitergibt?
            }
        }
    }
 
    public function archiveUrls() {
        if ($GLOBALS['egotec_conf']['rewrite_engine'] == 'url') {
            $db = new_db_connection();
            $db->begin();
 
            $db->update(array(
                'table' => 'egotec_url',
                'where' => 'site = :site AND lang = :lang AND id = :id AND canonical > 0',
                'bind' => array(
                    'site' => $this->_site->name,
                    'lang' => $this->_site->language,
                    'id' => $this->field['id']
                ),
                'set' => array(
                    'canonical' => 0
                )
            ));
 
            $db->commit();
        }
    }
 
    public function removeUrls() {
        if ($GLOBALS['egotec_conf']['rewrite_engine'] == 'url') {
            $db = new_db_connection();
            $db->begin();
 
            $db->delete(array(
                'table' => 'egotec_url',
                'where' => 'site = :site AND lang = :lang AND id = :id',
                'bind' => array(
                    'site' => $this->_site->name,
                    'lang' => $this->_site->language,
                    'id' => $this->field['id']
                )
            ));
 
            $db->commit();
        }
    }
 
    protected function getUrlNames() {
        // Der Name der Seite wird für die URL vorgesehen
        $name = $this->field['name'];
 
        // Zu verwendende Konfiguration ermitteln
        $conf = $this->_site->getRewriteConf();
 
        // Umlaute ersetzen
        if ($conf['umlauts']) {
            $name = str_replace(array('Ä', 'Ö', 'Ü', 'ä', 'ö', 'ü', 'ß'), array('Ae', 'Oe', 'Ue', 'ae', 'oe', 'ue', 'ss'), $name);
        }
 
        // Groß- und Kleinschreibung
        switch ($conf['case']) {
            // Alles groß
            case 'upper':
                $name = mb_strtoupper($name);
                break;
 
            // Alles klein
            case 'lower':
                $name = mb_strtolower($name);
        }
 
        // Leerzeichen ersetzen
        $space = $conf['space'];
        if (empty($space)) {
            $space = '+';
        }
        $name = str_replace(' ', $space, $name);
 
        // Und-Zeichen ausschreiben (über System-Übersetzungen, "var/lib/locale/", übersetzbar)
        if (!empty($conf['ampersand'])) {
            $language = $this->extra['language_link'][$this->_site->language] == 1
                ? $this->extra['language_standard']
                : $this->_site->language;
            $replace = $GLOBALS['auth']->translate('und', array(), $language);
            $name = str_replace('&', $replace, $name);
        }
 
        // Ungültige Zeichen entfernen
        $invalid_characters = "%\n\r\t,;#!?:&/'\".\\";
        $default_special = '_';
        $special = $conf['special'];
        if (empty($special)) {
            $special = $default_special;
        }
        $name = strtr($name, $invalid_characters, str_repeat($special, mb_strlen($invalid_characters)));
        if ($special != $default_special) {
            // Sicherstellen, dass das neue Zeichen für ungültige Zeichen nicht selbst ungültige Zeichen enthält
            $name = strtr($name, $invalid_characters, str_repeat($default_special, mb_strlen($invalid_characters)));
        }
 
        if ($name[0] == '-') {
            // Der Name darf nicht mit - beginnen (reserviert für Permalink)
            $name[0] = $special != '-' ? $special : $default_special;
        }
 
        // Ersetzte ungültige Zeichen zusammenfassen (beinhaltet auch ersetzte Leerzeichen)
        $name = preg_replace('/' . preg_quote($special, '/') . '{2,}/', $special, $name);
 
        // Fallback auf kundenspezifische Datei
        $url_file = $GLOBALS['egotec_conf']['var_dir'] . 'lib/url.php';
        if (Ego_System::file_exists($url_file)) {
            require_once $url_file;
            $result = get_url_names($this, $conf, $name/* Vom System generierter Name */);
            if (sizeof($result) > 0) {
                foreach ($result as $key => $value) {
                    if ($value[0] == '-') {
                        // Der Name darf nicht mit - beginnen (reserviert für Permalink)
                        $result[$key][0] = '_';
                    }
                }
                return $result;
            }
        }
 
        return array($name);
    }
 
 
    public function getPermUrl() {
        return $this->getUrl([
            'return_absolute' => true,
            'return_permalink' => true
        ]);
    }
 
 
    public function getPermissionName($perm) {
        $title = $perm;
 
        switch ($perm) {
            // Standardrechte
            case 'view':
                $title = $GLOBALS['auth']->translate('Ansicht');
                break;
            case 'edit':
                $title = $GLOBALS['auth']->translate('Bearbeiten');
                break;
            case 'release':
                $title = $GLOBALS['auth']->translate('Freigabe ändern');
                break;
            case 'remove':
                $title = $GLOBALS['auth']->translate('Löschen');
                break;
            case 'child':
                $title = $GLOBALS['auth']->translate('Ausschnitte/Seite anlegen');
                break;
            case 'workflow':
                $title = $GLOBALS['auth']->translate('Workflow ändern');
                break;
            case 'linkto':
                $title = $GLOBALS['auth']->translate('Verlinkung erlauben');
                break;
            case 'live':
                $title = $GLOBALS['auth']->translate('Übertragen');
                break;
 
            // Standardreiter
            case 'view_newsletter':
                $title = $GLOBALS['auth']->translate('Newsletter');
                break;
            case 'view_meta':
                $title = $GLOBALS['auth']->translate('Meta');
                break;
            case 'view_keywords':
                $title = $GLOBALS['auth']->translate('Schlagwortregister');
                break;
            case 'view_release':
                $title = $GLOBALS['auth']->translate('Freigabe');
                break;
            case 'view_navi':
                $title = $GLOBALS['auth']->translate('Navigation');
                break;
            case 'view_stats':
                $title = $GLOBALS['auth']->translate('Statistik');
                break;
            case 'view_workflow':
                $title = $GLOBALS['auth']->translate('Workflow');
                break;
            case 'view_rights':
                $title = $GLOBALS['auth']->translate('Rechte');
                break;
            case 'view_clone':
                $title = $GLOBALS['auth']->translate('Klone');
                break;
            case 'view_archive':
                $title = $GLOBALS['auth']->translate('Archiv');
                break;
            case 'view_media':
                $title = $GLOBALS['auth']->translate('Media');
        }
 
        // Kundenspezifischer Reiter
        $tabs = $this->getTabs();
        $real_perm = preg_replace('/^extra_/', '', $perm);
        if (isset($tabs[$real_perm])) {
            $title = $GLOBALS['auth']->translate($tabs[$real_perm]['title']);
        }
 
        return $title;
    }
 
    public function getTabs() {
        $nav_file = $GLOBALS['egotec_conf']['site_dir'].$this->_site->name.'/'.$this->field['type'].'/admin/navigation.ini';
 
        if ($this->_site->theme && !Ego_System::file_exists($nav_file))
        {
            $nav_file = $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme.'/site/'.$this->field['type'].'/admin/navigation.ini';
        }
 
        if ($this->_site->globalAllowed() && !Ego_System::file_exists($nav_file))
        {
            $nav_file = $GLOBALS['egotec_conf']['site_dir'].'_global/'.$this->field['type'].'/admin/navigation.ini';
        }
 
        if (!Ego_System::file_exists($nav_file)) {
            $nav_file = $GLOBALS['egotec_conf']['lib_dir'].'type/site/'.$this->field['type'].'/admin/navigation.ini';
        }
 
        if (!Ego_System::file_exists($nav_file))
        {
            $nav_file = $GLOBALS['egotec_conf']['site_dir'].$this->_site->name.'/page/admin/navigation.ini';
        }
 
        if (!Ego_System::file_exists($nav_file))
        {
            $nav_file = $GLOBALS['egotec_conf']['lib_dir'].'type/site/page/admin/navigation.ini';
        }
 
        $reiter = parse_ini_file($nav_file, true);
        $nav_file = $GLOBALS['egotec_conf']['site_dir'].$this->_site->name.'/admin/navigation.ini';
 
        if (Ego_System::file_exists($nav_file))
        { // Zusätzliche Reiter für jeden Seitentyp (aus site/mandant).
            $reiter = array_merge($reiter, parse_ini_file($nav_file, true));
        }
 
        if ($this->_site->theme) {
            $nav_file = $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme.'/site/admin/navigation.ini';
 
            if (Ego_System::file_exists($nav_file)) { // Zusätzliche Reiter für jeden Seitentyp (aus pub/theme).
                $reiter = array_merge($reiter, parse_ini_file($nav_file, true));
            }
        }
 
        if ($this->_site->globalAllowed()) {
            $nav_file = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/navigation.ini';
 
            if (file_exists($nav_file)) { // Zusätzliche Reiter für jeden Seitentyp (aus site/_global).
                $reiter = array_merge($reiter, parse_ini_file($nav_file, true));
            }
        }
 
        return $reiter;
    }
 
    public function updateLinks($inherited = true, $cleared = false) {
        $links = array();
 
        // Alle alten Verweise löschen
        if (!$cleared) {
            $this->removeLinks();
        }
 
        if (!$this->field['deleted']) {
            // Alle Verweise sammeln und speichern (nicht für Multimedia Dateien)
            if (!in_array($this->field['type'], array('multimedia/file', 'multimedia/image'))) {
                $this->updateLinksRecursive($links, $this->field['content'], true);
            }
            $this->updateLinksRecursive($links, $this->field['short'], true);
            $this->updateLinksRecursive($links, $this->extra);
 
            // Erweiterte Verweise aus Standard Blöcken sammeln
            if (is_array($this->extra['_blocks'])) {
                foreach ($this->extra['_blocks'] as $orient => $blocks) {
                    foreach ($blocks as $index => $block) {
                        $data = [];
                        if (is_array($this->extra['_contents'][$orient][$index])) {
                            $data = $this->extra['_contents'][$orient][$index];
                        }
 
                        switch ($block) {
                            // Medienliste
                            case 'medialist':
                                // Alle untergeordneten Dateien der Multimedia Kategorie sammeln
                                if (
                                    $data['extra']['source'] == 'multimedia'
                                    && !empty($data['extra']['category'])
                                    && ($category = Ego_System::urltopage($data['extra']['category'], ['auth_or' => '1=1']))
                                ) {
                                    $children = $category->getChildren(['where' => "type IN ('multimedia/file', 'multimedia/image')"]);
                                    foreach ($children as $child) {
                                        $links['pages'][] = array(
                                            'src_site' => $this->_site->name,
                                            'src_lang' => $this->_site->language,
                                            'src_id' => $this->field['id'],
                                            'dest_site' => $child->getSite()->name,
                                            'dest_lang' => $child->getSite()->language,
                                            'dest_id' => $child->field['id'],
                                            'tag' => '',
                                            'text' => '',
                                            'num' => 1,
                                            'extra_key' => implode(',', ['_contents', $orient, $index, 'extra', 'category'])
                                        );
                                    }
                                }
                        }
                    }
                }
            }
 
            // Die eingetragenen Benutzer einfügen
            foreach ($this->getUsersArray() as $perm => $users) {
                foreach ($users as $user) {
                    $links['users'][] = array(
                        'src_site' => $this->_site->name,
                        'src_lang' => $this->_site->language,
                        'src_id' => $this->field['id'],
                        'src_perm' => $perm,
                        'src_user' => '',
                        'dest_site' => '',
                        'dest_lang' => '',
                        'dest_id' => 0,
                        'dest_user' => $user['user_id'],
                        'extra_key' => ''
                    );
                }
            }
 
            $db = new_db_connection();
            $db->begin();
            foreach ($links as $type => $link_list) {
                $table = $type == 'pages' ? 'egotec_links' : 'egotec_user_links';
                if ($db->tableExists($table)) {
                    foreach ($link_list as $link) {
                        $db->insert(array(
                            'table' => $table,
                            'set' => $link
                        ));
                    }
                }
            }
            $db->commit();
 
            /* Bei einer Multimedia Datei müssen alle Verweise
             * auf eine Multimedia Kategorie aktualisiert werden */
            if ($inherited && $this->_site->site['type'] == 'media') {
                $params = array(
                    'inactive' => true,
                    'only_active' => false,
                    'no_cache' => true,
                    'auth_or' => '1=1',
                    'deleted' => -1
                );
                foreach ($this->getAncestors(array(
                    'where' => "type = 'multimedia/category'"
                ), $params) as $ancestor) {
                    $db->select(array(
                        'table' => 'egotec_links',
                        'where' => 'dest_site = :site AND dest_lang = :lang AND dest_id = :id',
                        'bind' => array(
                            'site' => $this->_site->name,
                            'lang' => $this->_site->language,
                            'id' => $ancestor->field['id']
                        )
                    ));
                    while ($db->nextRecord()) {
                        try {
                            $site = new Site($db->Record['src_site'], $db->Record['src_lang']);
                            if ($page = $site->getPage($db->Record['src_id'], $params)) {
                                $page->updateLinks(false, $cleared);
                            }
                        } catch (Site_Exception $e) {
                            // Mandant existiert nicht
                        }
                    }
                }
            }
        }
    }
 
    private function updateLinksRecursive(&$links, $data, $only_nodes = false, $extra = array(), $num = 0) {
        set_time_limit(0);
        $params = array(
            'inactive' => true,
            'only_active' => false,
            'no_cache' => true,
            'auth_or' => '1=1',
            'deleted' => -1
        );
        if (is_array($data)) {
            foreach ($data as $key => $value) {
                $tmp = $extra;
                $tmp[] = $key;
                $this->updateLinksRecursive($links, $value, $only_nodes, $tmp, $num);
            }
        } elseif (!empty($extra)) {
            try {
                if ($media = $this->_site->getMediaSite()) {
                    $more_links = array();
                    switch ($this->field['type']) {
                        case 'gallery':
                            if (
                                end($extra) == 'gallery_path'
                                && ($page = $media->getPage($data, array('internal' => true)))
                            ) {
                                $more_links[] = $page;
                                foreach ($page->getChildren(array(), $params) as $child) {
                                    $more_links[] = $child;
                                }
                            }
                            break;
                        case 'gallery2':
                            if (end($extra) == 'media_verz') {
                                $page = Ego_System::urltopage($data);
                                if ($page) {
                                    $more_links[] = $page;
                                    foreach ($page->getChildren(array(), $params) as $child) {
                                        $more_links[] = $child;
                                    }
                                }
                            }
                            break;
                        case 'medialist':
                        case 'buergerservice/leistung/entry':
                            if (end($extra) == 'multimedia_id') {
                                if (is_numeric($data)) {
                                    $page = $media->getPage($data, array('internal' => true));
                                } else {
                                    $page = Ego_System::urltopage($data);
                                }
                                if ($page) {
                                    $more_links[] = $page;
                                    foreach ($page->getDescendants(array(), $params) as $descendant) {
                                        $more_links[] = $descendant;
                                    }
                                }
                            }
                            break;
                        case 'buergerservice/leistung/list':
                            if (
                                end($extra) == 'mm_mainDir'
                                && ($page = $media->getPage($data, array('internal' => true)))
                            ) {
                                $more_links[] = $page;
                                foreach ($page->getDescendants(array(), $params) as $descendant) {
                                    $more_links[] = $descendant;
                                }
                            }
                            break;
                        case 'wiki/diskussion':
                        case 'wiki/kommentar':
                        case 'wiki/portal':
                        case 'wiki/portal_list':
                        case 'wiki/page':
                            if (end($extra) == 'documents') {
                                foreach (explode(',', $data) as $id) {
                                    if ($page = $media->getPage($id)) {
                                        $more_links[] = $page;
                                    }
                                }
                            }
                    }
 
                    $more_links = array_merge($more_links, $this->getMoreLinks());
 
                    reset($extra);
                    foreach ($more_links as $link) {
                        if (!$link) {
                            continue;
                        }
                        $links['pages'][] = array(
                            'src_site' => $this->_site->name,
                            'src_lang' => $this->_site->language,
                            'src_id' => $this->field['id'],
                            'dest_site' => $link->getSite()->name,
                            'dest_lang' => $link->getSite()->language,
                            'dest_id' => $link->field['id'],
                            'tag' => '',
                            'text' => '',
                            'num' => 1,
                            'extra_key' => implode(',', $extra)
                        );
                    }
                }
            } catch (Site_Exception $e) {
                // ignorieren
            }
        }
        if (is_string($data)) {
            // index.php URLs
            if ($only_nodes) {
                $pattern = '/(<([^> ]+) [^>]*)(href="|src="|data="|value="|archive="|class="|url\‍(\')([^,"\']*(index\.php\?|-site-)([^,"\']+))(["\'][^>]*>((.*?)<\/\\2>)?)/ims';
            } else {
                $pattern = '/(<([^> ]+) [^>]*)?(href="|src="|data="|value="|archive="|class="|url\‍(\')?([^,"\']*(index\.php\?|-site-)([^,"\']+))(["\'][^>]*>((.*?)<\/\\2>)?)?/ims';
            }
            if (preg_match_all($pattern, $data, $matches)) {
                foreach ($matches[0] as $index => $value) {
                    $url = rtrim($matches[4][$index], '\\');
                    $info = Ego_System::getUrlInfo(str_replace(
                        '&amp;amp;',
                        '&',
                        $url
                    ));
                    if(strlen($info['params']['lang']) != 2) {
                        continue;
                    }
                    if ($info['params']['p']) {
                        $info['params']['id'] = $info['params']['p'];
                    }
                    if ($info['params']['site'] && $info['params']['id']) {
                        $lang = $info['params']['lang'];
                        if (empty($lang)) {
                            try {
                                $site = new Site($info['params']['site']);
                                $site->addParam($params);
                            } catch (Exception $e) {
                                continue;
                            }
                            $lang = $site->language;
                        }
                        try {
                            $page = Ego_System::urltopage($url, array('params' => array('param' => $params)));
                        } catch (Exception $e) {
                            continue;
                        }
                        if (!$page) {
                            continue;
                        }
                        $text = (string)$matches[9][$index];
                        $links['pages'][] = array(
                            'src_site' => $this->_site->name,
                            'src_lang' => $this->_site->language,
                            'src_id' => $this->field['id'],
                            'dest_site' => (string)$info['params']['site'],
                            'dest_lang' => (string)$lang,
                            'dest_id' => (int)$info['params']['id'],
                            'tag' => (string)$matches[2][$index],
                            'text' => $text,
                            'num' => ++$num,
                            'extra_key' => implode(',', $extra)
                        );
                        if (trim($text) != '') {
                            $this->updateLinksRecursive($links, $text, $only_nodes, $extra, $num);
                        }
                        if (stripos($matches[0][$index], 'target="_lightbox"') !== false) {
                            // Bei einer Lightbox werden alle Geschwister ebenfalls verwendet
                            foreach ($page->getSiblings() as $sibling) {
                                if (
                                    $sibling->field['type'] == 'multimedia/image'
                                    && !$sibling->field['deleted']
                                    && !$sibling->field['inactive']
                                ) {
                                    $links['pages'][] = array(
                                        'src_site' => $this->_site->name,
                                        'src_lang' => $this->_site->language,
                                        'src_id' => $this->field['id'],
                                        'dest_site' => (string)$info['params']['site'],
                                        'dest_lang' => (string)$lang,
                                        'dest_id' => $sibling->field['id'],
                                        'tag' => (string)$matches[2][$index],
                                        'text' => $text,
                                        'num' => $num,
                                        'extra_key' => implode(',', $extra)
                                    );
                                }
                            }
                        }
                    }
                }
            }
 
            // Combo Plugin
            $pattern = '/^\{.*?"pages":\[\{.*?"(site|lang|id)":.*?\}\].*\}$/ims';
            if (preg_match_all($pattern, $data, $matches)) {
                require_once('base/Ego_Combo.php');
                foreach ($matches[0] as $value) {
                    try {
                        $combo = new Ego_Combo($value);
                        foreach ($combo->getPages(true) as $page) {
                            $links['pages'][] = array(
                                'src_site' => $this->_site->name,
                                'src_lang' => $this->_site->language,
                                'src_id' => $this->field['id'],
                                'dest_site' => $page->getSite()->name,
                                'dest_lang' => $page->getSite()->language,
                                'dest_id' => $page->field['id'],
                                'tag' => '',
                                'text' => '',
                                'num' => 1,
                                'extra_key' => implode(',', $extra)
                            );
                        }
                    } catch (Ego_Combo_Exception $e) {
                        // ignorieren
                    }
                }
            }
 
            // Identitäten
            $pattern = '/[a-z0-9_]+'
                .preg_quote(self::IDENTITY_SEPARATOR, '/')
                .'[a-z]{2}'
                .preg_quote(self::IDENTITY_SEPARATOR, '/')
                .'\d+/ims';
            if (preg_match_all($pattern, $data, $matches)) {
                foreach ($matches[0] as $value) {
                    try {
                        $page = self::byIdentity($value, $params);
                        if ($page) {
                            $links['pages'][] = array(
                                'src_site' => $this->_site->name,
                                'src_lang' => $this->_site->language,
                                'src_id' => $this->field['id'],
                                'dest_site' => $page->getSite()->name,
                                'dest_lang' => $page->getSite()->language,
                                'dest_id' => $page->field['id'],
                                'tag' => '',
                                'text' => '',
                                'num' => 1,
                                'extra_key' => implode(',', $extra)
                            );
                        }
                    } catch (Site_Exception $e) {
                        // ignorieren
                    }
                }
            }
 
            // Suche nach 32-Zeichen langen alphanumerischen Hashes und prüfe, ob diese User-IDs sind
            if ($extra[0] != 'history') {
                $pattern = '/(?<![a-z0-9])([a-z0-9]{32})(?![a-z0-9])/i';
                if (preg_match_all($pattern, $data, $matches)) {
                    foreach ($matches[0] as $index => $values) {
                        $db = new_db_connection([
                            'table' => 'egotec_user',
                            'where' => 'user_id = :user_id',
                            'bind' => [
                                'user_id' => $matches[1][$index]
                            ]
                        ]);
                        if ($db->nextRecord()) {
                            $links['users'][] = array(
                                'src_site' => $this->_site->name,
                                'src_lang' => $this->_site->language,
                                'src_id' => $this->field['id'],
                                'src_perm' => '',
                                'src_user' => '',
                                'dest_site' => '',
                                'dest_lang' => '',
                                'dest_id' => 0,
                                'dest_user' => $db->Record['user_id'],
                                'extra_key' => implode(',', $extra)
                            );
                        }
                    }
                }
            }
        }
    }
 
    public function removeLinks() {
        $db = new_db_connection();
 
        // Seiten Verweise löschen
        $db->delete(array(
            'table' => 'egotec_links',
            'where' => "src_site = '{$this->_site->name}'"
                ." AND src_lang = '{$this->_site->language}'"
                ." AND src_id = '{$this->field['id']}'"
        ));
 
        // Benutzer Verweise löschen
        if ($db->tableExists('egotec_user_links')) {
            $db->delete(array(
                'table' => 'egotec_user_links',
                'where' => "src_site = '{$this->_site->name}'"
                    ." AND src_lang = '{$this->_site->language}'"
                    ." AND src_id = '{$this->field['id']}'"
            ));
        }
    }
 
    public function getLinks($recursive = false, $c_date = false) {
        $links = array();
        $c_dates = array();
 
        $db = new_db_connection();
        $db->select(array(
            'table' => 'egotec_links',
            'where' => "src_site = :site AND src_lang = :lang AND src_id = :id",
            'bind' => array(
                'site' => $this->_site->name,
                'lang' => $this->_site->language,
                'id' => $this->field['id']
            )
        ));
        while ($db->nextRecord()) {
            $record = $db->Record;
            $key = md5(serialize(array($db->Record['dest_site'], $db->Record['dest_lang'])));
            $page = null;
 
            if ($recursive || $c_date) {
                // Bei Multimedia Kategorien auch alle Nachfahren ermitteln
                try {
                    $query = array();
                    $param = array(
                        'auth_or' => '1=1',
                        'deleted_or' => '1=1',
                        'inactive' => true,
                        'only_active' => false
                    );
 
                    $site = new Site($db->Record['dest_site'], $db->Record['dest_lang']);
                    $page = $site->getPage($db->Record['dest_id'], $param);
 
                    if ($page) {
                        if ($c_date) {
                            // Nur Nachfahren ermitteln, die seit dem letzten Liveabgleich geändert wurden
                            if (!isset($c_dates[$key])) {
                                $c_dates[$key] = '';
 
                                $clusters = Ego_System::getCluster($site);
                                if (!empty($clusters)) {
                                    // Cluster
                                    foreach ($clusters as $cluster) {
                                        $file = $GLOBALS['egotec_conf']['log_dir'] . $db->Record['dest_site'] . '/live.' . $db->Record['dest_site'] . '_' . $db->Record['dest_lang'] . '.' . $cluster['id'] . '.date';
                                        if (Ego_System::file_exists($file)) {
                                            $date = Ego_System::file_get_contents($file);
                                            if (empty($c_dates[$key]) || $date < $c_dates[$key]) {
                                                $c_dates[$key] = $date;
                                            }
                                        }
                                    }
                                } else {
                                    // Live
                                    $file = $GLOBALS['egotec_conf']['log_dir'] . $db->Record['dest_site'] . '/live.' . $db->Record['dest_site'] . '_' . $db->Record['dest_lang'] . '.date';
                                    if (Ego_System::file_exists($file)) {
                                        $c_dates[$key] = Ego_System::file_get_contents($file);
                                    }
                                }
                            }
 
                            if (!empty($c_dates[$key])) {
                                $query['where'] = 'm_date > :c_date';
                                $query['bind'] = array(
                                    'c_date' => $c_dates[$key]
                                );
                            }
                        }
 
                        if ($recursive && $page->field['type'] == 'multimedia/category') {
                            $descendants = $page->getDescendants($query, $param);
                            $record['descendants'] = 0;
                            foreach ($descendants as $descendant) {
                                $record['descendants']++;
                                $link = $db->Record;
                                $link['dest_id'] = $descendant->field['id'];
                                $link['recursive'] = true;
                                $links[] = $link;
                            }
                        }
                    }
                } catch (Site_Exception $e) {
                    // ignorieren
                }
            }
 
            if ($c_date && !empty($c_dates[$key]) && $page && $page->field['m_date'] <= $c_dates[$key] && empty($record['descendants'])) {
                // Verweis ignorieren, wenn er seit dem letzten Liveabgleich nicht geändert wurde und keine relevanten Nachfahren besitzt
                continue;
            }
 
            $links[] = $record;
        }
        return $links;
    }
 
    public function getLinkedPages($recursive = false, $self = true) {
        $links = array();
        $param = array(
            'inactive' => true,
            'only_active' => false,
            'no_cache' => true,
            'auth_or' => '1=1',
            'deleted' => -1
        );
 
        $db = new_db_connection();
        if ($self) {
            foreach ($this->_site->getLanguages() as $lang) {
                if ($page = $this->getLanguagePage($lang, $param)) {
                    $db->select(array(
                        'table' => 'egotec_links',
                        'where' => "dest_site = :site1 AND dest_lang = :lang AND dest_id = :id1"
                            ." AND (src_site != :site2 OR src_id != :id2)", // Auf sich selbst ignorieren
                        'bind' => array(
                            'site1' => $this->_site->name,
                            'lang' => $lang,
                            'id1' => $this->field['id'],
                            'site2' => $this->_site->name,
                            'id2' => $this->field['id']
                        ),
                        'order' => 'num ASC'
                    ));
                    if ($db->nextRecord()) {
                        $link = array(
                            'page' => $page,
                            'sources' => array()
                        );
 
                        // Klone werden ignoriert
                        $clones = array();
                        if ($page->extra['clones']) {
                            foreach (explode(',', $page->extra['clones']) as $clone) {
                                $info = Ego_System::getUrlInfo($clone);
                                $clones[] = self::createIdentity($info['params']);
                            }
                        }
 
                        do {
                            $record = $db->Record;
 
                            // Klone werden ignoriert
                            if (!empty($clones) && in_array(self::createIdentity(array(
                                    'site' => $record['src_site'],
                                    'lang' => $record['src_lang'],
                                    'id' => $record['src_id']
                                )), $clones)) {
                                continue;
                            }
 
                            try {
                                // Nur wenn diese Seite existiert
                                $db2 = new_db_connection(array(
                                    'table' => $record['src_site'] . '_' . $record['src_lang'],
                                    'where' => 'id = :id',
                                    'bind' => array(
                                        'id' => $record['src_id']
                                    )
                                ));
                            } catch (Ego_Sql_Exception $e) {
                                continue 2;
                            }
                            while (!$db2->nextRecord()) {
                                continue 2;
                            }
 
                            $src_site = $record['src_site'];
                            $src_lang = $record['src_lang'];
                            $src_id = $record['src_id'];
 
                            // Prüfen, ob es sich um einen JSON String handelt
                            $record['json'] = false;
                            if ($record['extra_key']) {
                                $src_page = Page::byIdentity(self::createIdentity(array(
                                    'site' => $src_site,
                                    'lang' => $src_lang,
                                    'id' => $src_id
                                )), array(
                                    'inactive' => true,
                                    'only_active' => false,
                                    'auth_or' => '1=1'
                                ));
 
                                if ($src_page) {
                                    $src_value = Ego_System::getAssocValue($src_page->extra, str_replace(',', '.', $record['extra_key']));
                                    if (strpos($src_value, '{') === 0 && @json_decode($src_value)) {
                                        $record['json'] = true;
                                    }
                                }
                            }
 
                            $link['sources'][$src_site][$src_lang][$src_id][] = $record;
                        } while ($db->nextRecord());
                        if (!empty($link['sources'])) {
                            $links[] = $link;
                        }
                    }
                }
            }
        }
 
        if ($recursive) {
            $descendants = $this->getDescendants(array(), $param);
            foreach ($descendants as $descendant) {
                $links = array_merge($links, $descendant->getLinkedPages());
            }
        }
 
        return $links;
    }
 
    public function getLinkedUsers() {
        $links = [];
 
        $db = new_db_connection();
        foreach ($this->_site->getLanguages() as $lang) {
            $db->select([
                'table' => 'egotec_user_links, egotec_user',
                'fields' => '`egotec_user_links`.*, `egotec_user`.username',
                'where' => "`egotec_user_links`.src_user = `egotec_user`.user_id AND dest_site = :site AND dest_lang = :lang AND dest_id = :id",
                'bind' => [
                    'site' => $this->_site->name,
                    'lang' => $lang,
                    'id' => $this->field['id'],
                ],
                'order' => '`egotec_user`.username ASC'
            ]);
 
            if ($db->nextRecord()) {
                do {
                    $record = $db->Record;
                    $user = new User_SQL($record['src_user']);
 
                    $links[] = [
                        'extra' => $record['extra_key'],
                        'username' => $user->getFullname(),
                        'edit' => $GLOBALS['auth']->hasPermissionOn($user),
                        'url' => get_url('admin.php', [
                            'view' => 'users',
                            'user_id' => $record['src_user']
                        ])
                    ];
                } while ($db->nextRecord());
            }
        }
 
        return $links;
    }
 
    public function getMoreLinks() {
        return [];
    }
 
    public function getIconUrl($test = false, $folder = false, $quarantine = true) {
        if ($quarantine && ($this->extra['quarantine'] || stristr($this->field['extra'], '"quarantine"'))) {
            // Quarantäne
            return $GLOBALS['egotec_conf']['url_dir'].'bin/admin_skin/egotec/img/16x16/attention.png';
        }
        if ($this->extra['crop_image']) {
            // Bildausschnitt
            return $GLOBALS['egotec_conf']['url_dir'].'bin/admin_skin/egotec/img/16x16/crop.png';
        }
        $url = $test
            ? '' // Falls diese Page kein spezielles Icon hat, dann nichts zurückgeben
            : ($folder && $this->hasChildren(array(), array('auth_or' => '1=1'))
                ? $GLOBALS['egotec_conf']['url_dir'].'bin/admin_skin/egotec/img/16x16/folder.png'
                : $GLOBALS['egotec_conf']['url_dir'].'bin/admin_skin/egotec/img/16x16/page.png');
        $this->getTypeInfo();
        if (!empty($this->typeInfo)) {
            if (!empty($this->typeInfo['icon'])) {
                $icon = $this->typeInfo['icon'];
                $get_path = function() use ($icon) {
                    $real_path = (string) realpath($icon);
                    $dir_pos = strpos($real_path, $GLOBALS['egotec_conf']['egotec_dir']);
                    if ($dir_pos === false) {
                        // Kann der Pfad nicht gefunden werden, dann automatisch ermitteln
                        $tmp = explode(DIRECTORY_SEPARATOR, trim($GLOBALS['egotec_conf']['egotec_dir'], DIRECTORY_SEPARATOR));
 
                        $dir = DIRECTORY_SEPARATOR
                            . array_pop($tmp)
                            . DIRECTORY_SEPARATOR;
                        if ($dir_pos = strpos($real_path, $dir)) {
                            return substr($real_path, $dir_pos + strlen($dir));
                        }
                    }
                    return substr($real_path, $dir_pos + strlen($GLOBALS['egotec_conf']['egotec_dir']));
                };
                $path = $get_path(); // Abwärtskompatibilität: Pfad mit ../
                if (!$path) {
                    // Pfad ausgehend von egotec_dir
                    $cwd = getcwd();
                    chdir($GLOBALS['egotec_conf']['egotec_dir']);
                    $path = $get_path();
                    chdir($cwd);
                }
                $url = $GLOBALS['egotec_conf']['url_dir'] . $path;
            } elseif (!empty($this->extra['image_type']) && !$folder) {
                $mime = strtolower($this->extra['image_type']);
                switch ($mime) {
                    case 'jpeg':
                        $mime = 'jpg';
                        break;
                    case 'mdb':
                        $mime = 'access';
                        break;
                    case 'htm':
                        $mime = 'html';
                }
                if (Ego_System::file_exists($GLOBALS['egotec_conf']['bin_dir'].'admin_skin/egotec/img/icons/small/2013/'.$mime.'.png')) {
                    $url = $GLOBALS['egotec_conf']['url_dir'].'bin/admin_skin/egotec/img/icons/small/2013/'.$mime.'.png';
                }
            }
        }
        return $url;
    }
 
    public function getTypeInfo($cache = true) {
        if (!$cache || empty($this->typeInfo)) {
            $key = 'type'.md5(serialize(array($this->_site->name, $this->field['type'])));
            $cache = $this->_site->getCacheEntry($key);
            if ($cache === null) {
                if ($file = $this->_site->getSiteFile($this->field['type'] . DIRECTORY_SEPARATOR . 'type.ini')) {
                    $this->typeInfo = @parse_ini_file($file, true);
                    $this->_site->setCacheEntry($key, is_array($this->typeInfo) ? $this->typeInfo : array());
                }
            } else {
                $this->typeInfo = $cache;
            }
        }
        return $this->typeInfo;
    }
 
    public function canChangeType() {
        $type_info = $this->getTypeInfo();
        return $this->_site->hasRight('change_type') && empty($type_info['unchangeable']);
    }
 
    public function getEditorCSS() {
        $css = array();
        $content_css = '';
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/editor.css")) {
            $css['skin']['editor'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/editor.css";
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/editor.css")) {
            $css['global']['editor'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/editor.css";
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/table.css")) {
            $css['skin']['table'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/table.css";
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/table.css")) {
            $css['global']['table'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/table.css";
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/span.css")) {
            $css['skin']['span'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/span.css";
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/span.css")) {
            $css['global']['span'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/span.css";
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/img.css")) {
            $css['skin']['img'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/img.css";
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/img.css")) {
            $css['global']['img'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/img.css";
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/link.css")) {
            $css['skin']['link'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/link.css";
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/link.css")) {
            $css['global']['link'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/link.css";
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/".$this->field['type']."/style.css")) {
            $css['type']['style'] = $GLOBALS['egotec_conf']['url_dir']."skin/".$this->_site->skin."/".$this->field['type']."/style.css";
            $content_css = $css['type']['style'];
        }
        if (Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir'].$this->_site->skin."/style.css")) {
            $css['skin']['style'] = $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->_site->skin."/style.css";
            $content_css = $css['skin']['style'];
        }
        if ($this->_site->globalAllowed() && Ego_System::file_exists($GLOBALS['egotec_conf']['skin_dir']."_global/style.css")) {
            $css['global']['style'] = $GLOBALS['egotec_conf']['url_dir']."skin/_global/style.css";
            $content_css = $css['global']['style'];
        }
        if (
            $this->extra['_style']
            && ($file = $this->_site->getSkinFile($this->field['type'].'/style.'.$this->extra['_style'].'.css', array(), true))
        ) {
            $css['variant']['style'] = $file;
            $content_css = $css['variant']['style'];
        }
 
        // CSS Dateien aus der Designvorlage
        if ($this->_site->theme) {
            if (empty($css['theme']['editor']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/editor.css")) {
                $css['theme']['editor'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/editor.css";
            }
            if (empty($css['theme']['table']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/table.css")) {
                $css['theme']['table'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/table.css";
            }
            if (empty($css['theme']['span']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/span.css")) {
                $css['theme']['span'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/span.css";
            }
            if (empty($css['theme']['img']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/img.css")) {
                $css['theme']['img'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/img.css";
            }
            if (empty($css['theme']['link']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/link.css")) {
                $css['theme']['link'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/link.css";
            }
            if (empty($css['theme']['style']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/".$this->field['type']."/style.css")) {
                $css['theme']['type'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/".$this->field['type']."/style.css";
            }
            if (empty($css['theme']['style']) && Ego_System::file_exists($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->_site->theme."/skin/style.css")) {
                $css['theme']['style'] = $GLOBALS['egotec_conf']['url_dir'].'pub/theme/'.$this->_site->theme."/skin/style.css";
            }
        }
 
        // admin.css einbinden
        if ($GLOBALS['admin_area'] && ($file = $this->_site->getSkinFile('admin.css', array(), true))) {
            $css['admin']['style'] = $file;
        }
 
        return array(
            'css' => $css,
            'content_css' => $content_css
        );
    }
 
    public function getLinkText() {
        return $this->field['name'];
    }
 
    public function getIdentity() {
        return self::createIdentity(array(
            'site' => $this->_site->name,
            'lang' => $this->_site->language,
            'id' => $this->field['id']
        ));
    }
 
    public static function isIdentity($identity) {
        return is_string($identity)
            && ($v = explode(self::IDENTITY_SEPARATOR, $identity))
            && sizeof($v) == 3
            && !is_numeric($v[0])
            && strlen($v[1]) == 2
            && is_numeric($v[2]);
    }
 
    public static function createIdentity($params) {
        return implode(self::IDENTITY_SEPARATOR, array($params['site'], $params['lang'], $params['id']));
    }
 
    public static function byIdentity($identity, $param = array(), $site = null) {
        [$name, $lang, $id] = explode(self::IDENTITY_SEPARATOR, $identity);
        try {
            if (
                !$site
                || $site->name != $name
                || $site->language != $lang
            ) {
                if (
                    $GLOBALS['site']
                    && $GLOBALS['site']->name == $name
                    && $GLOBALS['site']->language == $lang
                ) {
                    $site = $GLOBALS['site'];
                } else {
                    $site = new Site($name, $lang, '', !$GLOBALS['admin_area'] || $_SESSION['login']['live_preview']);
                }
            }
            if (!is_array($param)) {
                $param = array();
            }
            return $site->getPage($id, $param);
        } catch (Site_Exception $e) {
            // ignorieren
        }
        return null;
    }
 
    public function inheritExtra($keys, $mixed = false, $types = array(), $no_rights = true) {
        $cache_key = 'inherit'.md5(serialize([$this->getIdentity(), $keys, $mixed, $types, $no_rights]));
        $cache_entry = $this->_site->getCacheEntry($cache_key);
 
        if ($cache_entry === null) {
            $values = array();
 
            if (!empty($keys)) {
                $query = array();
                if (!empty($types)) {
                    // Die Vorfahren müssen einen bestimmten Seitentyp haben
                    $query['where'] = array();
                    $query['bind'] = array();
                    $n = 0;
                    foreach ($types as $type) {
                        $query['where'][] = 'type = :type'.(++$n);
                        $query['bind']['type'.$n] = $type;
                    }
                    $query['where'] = implode(' OR ', $query['where']);
                }
                $param = array();
                if ($no_rights) {
                    // Keine Rechteprüfung
                    $param['auth_or'] = '1=1';
                }
 
                $ancestors = array();
                // Vorfahren umdrehen
                foreach ($this->getAncestors($query, $param) as $ancestor) {
                    $ancestors[] = $ancestor;
                }
                $ancestors = array_reverse($ancestors);
                array_unshift($ancestors, $this);
                foreach ($ancestors as $ancestor) {
                    foreach ($keys as $key) {
                        $value = Ego_System::getAssocValue($ancestor->extra, $key);
                        if ($value !== null && !isset($values[$key])) {
                            $values[$key] = $value;
                            if (!$mixed) {
                                // Alle Werte dieses Vorfahren übernehmen
                                foreach ($keys as $k) {
                                    if ($key != $k) {
                                        $v = Ego_System::getAssocValue($ancestor->extra, $k);
                                        if ($v !== null) {
                                            $values[$k] = $v;
                                        }
                                    }
                                }
                                break 2;
                            }
                        }
                    }
                }
            }
 
            $this->_site->setCacheEntry($cache_key, $values);
        } else {
            $values = $cache_entry;
        }
        return $values;
    }
 
    public function addPiwikSite() {
        require_once 'stats/Ego_Piwik.php';
        $piwik = new Ego_Piwik();
        $piwikdata = $piwik->createWebsite($this);
        if (!is_array($piwikdata)) {
            return null;
        }
        return $piwikdata;
    }
 
    public function isUniqueUrl($url) {
        $ignore_ids = array($this->field['id']);
 
        // Seite ist eine Workflow-, Freigabekopie: Meta URL der Originalseite ignorieren
        if ($this->isWorkflowCopy()) {
            $ignore_ids[] = (int) $this->extra['original_id'];
 
            $original_page = $this->_site->getPage((int) $this->extra['original_id']);
            if (!empty($original_page->extra['release_ids'])) {
                foreach ($original_page->extra['release_ids'] as $release_id) {
                    $ignore_ids[] = (int) $release_id;
                }
            }
        }
        if ($this->isReleaseCopy()) {
            $ignore_ids[] = (int) $this->extra['release_id'];
 
            $original_page = $this->_site->getPage((int) $this->extra['release_id']);
            if (!empty($original_page->extra['workflow_page'])) {
                $ignore_ids[] = (int) $original_page->extra['workflow_page'];
            }
        }
 
        // Seite hat Workflow-, Freigabekopien: Meta URLs dieser Seiten ignorieren
        if (!empty($this->extra['release_ids'])) {
            foreach ($this->extra['release_ids'] as $release_id) {
                $ignore_ids[] = (int) $release_id;
            }
        }
        if (!empty($this->extra['workflow_page'])) {
            $ignore_ids[] = (int) $this->extra['workflow_page'];
        }
 
        $db = new_db_connection(array(
            'table' => $this->_site->pageTable,
            'where' => 'url = :url AND deleted = 0 AND id NOT IN (' . implode(', ', array_unique($ignore_ids)) . ')',
            'bind' => array(
                'url' => $url
            )
        ));
        if (!$db->nextRecord()) {
            // Bei der flachen URL Generierung darf es keine Seite mit diesem Namen geben
            if ($GLOBALS['egotec_conf']['rewrite_engine'] == 'flat') {
                $db->select(array(
                    'table' => $this->_site->pageTable,
                    'where' => 'name = :name AND id != :id AND deleted = 0',
                    'bind' => array(
                        'name' => $url,
                        'id' => $this->field['id']
                    )
                ));
                if ($db->nextRecord()) {
                    return false;
                }
            }
 
            // Bei der Standard URL Generierung darf es keine Seite in erster Ebene mit diesem Namen geben
            if (empty($GLOBALS['egotec_conf']['rewrite_engine'])) {
                $db->select(array(
                    'table' => $this->_site->pageTable,
                    'where' => 'page_id = :root_id AND name = :name AND id != :id AND deleted = 0',
                    'join' => $this->_site->pageTable.'_children ON ('.$this->_site->pageTable.'_children.child = id)',
                    'bind' => array(
                        'root_id' => $this->_site->rootId,
                        'name' => $url,
                        'id' => $this->field['id']
                    )
                ));
                if ($db->nextRecord()) {
                    return false;
                }
            }
 
            // Der Name darf nicht von einem Mandanten verwendet werden
            foreach (Ego_System::getAllSites() as $site) {
                if ($site->name == $url) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
 
    public function validateFile($source, $name = '', $form = array(), $files_conf = array()) {
        $files_list = array();
 
        // Übergebene Einstellungen verwenden
        if (!empty($files_conf)) {
            $files_list[] = $files_conf;
        }
 
        // Einstellungen des Dateiupload Feldes verwenden (alter Editor)
        if (!empty($form) && !empty($this->extra['mandatory'][$form['form']][$form['field']]['files'])) {
            $files_list[] = $this->extra['mandatory'][$form['form']][$form['field']]['files'];
        }
 
        // Einstellungen des Mandanten verwenden
        if (!empty($this->_site->admin['files'])) {
            $files_list[] = $this->_site->admin['files'];
        }
 
        // Einstellungen der globalen Konfiguration verwenden
        if (!empty($GLOBALS['egotec_conf']['files'])) {
            $files_list[] = $GLOBALS['egotec_conf']['files'];
        }
 
        if (!empty($files_list)) {
            // Die Datei zuerst vom Virenscanner überprüfen lassen
            foreach ($files_list as $files) {
                if ($files['validate_files']) {
                    try {
                        Ego_System::scan($source);
                    } catch (Exception $e) {
                        egotec_error_log($e->getMessage());
                        return false;
                    }
 
                    // Die Prüfung abbrechen, da sie erfolgreich war
                    break;
                }
            }
 
            // Die Datei erst nach dem Virenscanner verarbeiten
            require_once('base/Ego_MimeType.php');
            $mime = new Ego_MimeType();
            $prepare_type = function($t) {
                return trim(ltrim(mb_strtolower($t), "."));
            };
            $type = $prepare_type(pathinfo($name ? $name : @basename($source), PATHINFO_EXTENSION));
            $size = @filesize($source);
 
            foreach ($files_list as $files) {
                if (
                    !empty($files['whitelist'])
                    || !empty($files['blacklist'])
                    || !empty($files['filesize'])
                ) {
                    $whitelist = array_map($prepare_type, explode(',', (string) $files['whitelist']));
                    $blacklist = array_map($prepare_type, explode(',', (string) $files['blacklist']));
                    if (
                        (!empty($files['whitelist']) && (!in_array($type, $whitelist) || !$mime->hasMimeType($source, $whitelist)))
                        || (!empty($files['blacklist']) && empty($files['whitelist']) && (in_array($type, $blacklist) || $mime->hasMimeType($source, $blacklist)))
                        || (!empty($files['filesize']) && $size > (int) $files['filesize'])
                    ) {
                        return false;
                    }
 
                    // Die Prüfung abbrechen, da die Anforderungen erfüllt sind
                    break;
                }
            }
        }
 
        return true;
    }
 
    public function isFrontendAdmin($check_rights = true) {
        $info = $this->getTypeInfo();
        return $this->_site->isFrontendAdmin($check_rights)
            && !$info['frontend_ignore']
            && (
                !$check_rights
                || $this->hasRights(array('view'))
            );
    }
 
    public function isCurrentPage($lang = false) {
        return ($_REQUEST['site'] ? $_REQUEST['site'] : $GLOBALS['default_site']) == $this->_site->name
            && (!$lang || ($_REQUEST['lang'] ? $_REQUEST['lang'] : $this->_site->site['default_language']) == $this->_site->language)
            && ($_REQUEST['id'] ? $_REQUEST['id'] : ($_REQUEST['list'] ? $_REQUEST['list'] : $this->_site->rootId)) == $this->field['id'];
    }
 
    public function setCurrentPage() {
        $_REQUEST['site'] = $this->_site->name;
        $_REQUEST['lang'] = $this->_site->language;
        $_REQUEST['id'] = $this->field['id'];
        $GLOBALS['site'] = &$this->_site;
        $GLOBALS['page'] = &$this;
    }
 
    public function reset($self = true) {
        $db = new_db_connection();
 
        // Archiv
        if ($self) {
            // Zurücksetzen
            $db->delete(array(
                'table' => $this->_site->pageTable.'_v',
                'where' => "id = {$this->field['id']} AND m_date > :date",
                'bind' => array(
                    'date' => $this->lastChangeDate
                )
            ));
        } else {
            // Veröffentlichen
            $db->delete(array(
                'table' => $this->_site->pageTable.'_v',
                'where' => "id = {$this->field['id']} AND m_date > :date1 AND m_date != :date2",
                'bind' => array(
                    'date1' => $this->lastChangeDate,
                    'date2' => $this->field['m_date']
                )
            ));
        }
 
        // Mediapool
        $last_c_date = Ego_System::dateEncode($this->lastChangeDate);
        $this_c_date = Ego_System::dateEncode($this->field['m_date']);
        foreach (glob($this->getMediapool()->dir().'*', GLOB_ONLYDIR) as $dir) {
            $dir_c_date = basename($dir);
            if (
                is_numeric($dir_c_date)
                && (int) $dir_c_date != $this_c_date
                && (int) $dir_c_date > $last_c_date
            ) {
                Ego_System::deldir($dir);
            }
        }
    }
 
    public function getNextReplicationDate() {
        return $this->_site->getNextReplicationDate($this);
    }
 
    public function getCacheEntry($key) {
        return $this->_site->getCacheEntry("{$key}_{$this->field['id']}");
    }
 
    public function setCacheEntry($key, $value) {
        $this->_site->setCacheEntry("{$key}_{$this->field['id']}", $value);
    }
 
    public function getListItems($where = '', $no_limit = false) {
        $items = array();
 
        $limit = (isset($_REQUEST['dt']['start']) && !$no_limit
            ? $_REQUEST['dt']['start'] . ',' . $_REQUEST['dt']['length']
            : '');
        $order = '';
 
        // Bei der Server seitigen Abfrage wird die Sortierung übergeben
        if (
            isset($_REQUEST['dt']['order'])
            && isset($_REQUEST['dt']['order']['dir'])
            && isset($_REQUEST['dt']['order']['field'])
        ) {
            switch ($_REQUEST['dt']['order']['dir']) {
                case 'asc':
                    $order = $_REQUEST['dt']['order']['field'] . ' ASC';
                    break;
                case 'desc':
                    $order = $_REQUEST['dt']['order']['field'] . ' DESC';
            }
        }
 
        $query = array(
            'where' => $where
        );
 
        if ($limit != '') {
            $query['limit'] = $limit;
            $query['order'] = $order == '' ? 'id ASC' : $order;
        }
 
        foreach ($this->getChildren($query, array(
            'inactive' => true,
            'only_active' => false
        )) as $child) {
            $child->field['identity'] = $child->getIdentity();
            $items[] = $child;
        }
 
        // Bei der Server seitigen Abfrage ist die maximale Anzahl erforderlich
        if (isset($_REQUEST['dt']['start'])) {
            $_REQUEST['dt']['total'] = $this->getChildren(array(
                'where' => $where,
            ), array(
                'inactive' => true,
                'only_active' => false
            ))->numRecords();
        }
 
        return $items;
    }
 
    public function addListItem($params) {
        $this->newChild(array(
            'name' => (string) $params['data']->name,
            'title' => (string) $params['data']->name,
            'type' => $params['type'] ? $params['type'] : 'page'
        ));
    }
 
    public function removeListItem($params) {
        if ($page = self::byIdentity($params['identity'])) {
            $page->destroy();
            return true;
        }
        return false;
    }
 
    public function removeSelectedListItem($params) {
        foreach ($params['data']->identities as $identity) {
            if ($page = self::byIdentity($identity)) {
                $page->destroy();
            }
        }
        return true;
    }
 
    public function reorderListItem($params) {
        $children = array();
        foreach ($params['data'] as $identity) {
            [$name, $lang, $id] = explode(self::IDENTITY_SEPARATOR, $identity);
            if ($name == $this->_site->name && $lang == $this->_site->language) {
                $children[] = (int) $id;
            }
        }
 
        $this->archiveOnly = false;
        $this->update(array(
            'field' => array(
                'children_order' => 'children'
            ),
            'children' => $children
        ));
    }
 
    public function getFormListConf($orient) {
        $conf = array(
            'a_date' => array(
                'title' => $GLOBALS['auth']->translate('Empfangen'),
                'formatter' => 'date',
                'sortable' => true,
                'width' => '15%'
            )
        );
        if (is_array($this->extra['_blocks'][$orient])) {
            $upload = false;
            foreach ($this->extra['_blocks'][$orient] as $index => $block) {
                if (strpos($block, 'input_') === 0 && $block != 'input_submit' && isset($this->extra['_contents'][$orient][$index])) {
                    if ($block == 'input_file' && $this->extra['_forms'][$orient]['export'] == 'page') {
                        $upload = true;
                        continue;
                    }
                    $content = $this->extra['_contents'][$orient][$index];
                    $label = $content['label'] ? trim($content['label'], ' :') : $content['extra']['name'];
                    if ($block == 'input_checkbox') {
                        require_once 'base/Ego_Combo.php';
                        $combo = new Ego_Combo($content['extra']['values']);
                        foreach ($combo->getData() as $data) {
                            $conf["data.{$data->field_name}"] = array(
                                'title' => $label . ': ' . ($data->label ? trim($data->label, ' :') : $data->field_name),
                                'type' => 'extra',
                                'sortable' => false
                            );
                        }
                    } elseif (isset($content['extra']['name'])) {
                        $conf["data.{$content['extra']['name']}"] = array(
                            'title' => $content['label'] ? trim($content['label'], ' :') : $content['extra']['name'],
                            'type' => 'extra',
                            'sortable' => false
                        );
                    }
                }
            }
            if ($upload) {
                // Mediapool der Unterseiten anzeigen
                $conf['pool'] = array(
                    'title' => $GLOBALS['auth']->translate('Dateien'),
                    'formatter' => 'pool',
                    'width' => 75,
                    'align' => 'center',
                    'sortable' => false
                );
            }
        }
        return $conf;
    }
 
    public function getDataConf($type = '') {
        $data = [];
 
        $files = Ego_System::getFiles('site', $this->_site->name, ($type ?: $this->field['type']) . '/admin/data.json', [], $this->_site->theme, true);
        foreach (array_keys(array_reverse($files)) as $file) {
            if ($file != '_empty') {
                $new_data = json_decode(Ego_System::file_get_contents($GLOBALS['egotec_conf']['egotec_dir'] . $file), true);
                if ($new_data['extend']) {
                    // Konfigurationen zusammenführen
                    $data = array_merge_recursive($data, $new_data);
                } else {
                    // Konfigurationen überschreiben
                    $data = $new_data;
                }
            }
        }
 
        return $data;
    }
 
    public function fetch($params = array(), $outputfilter = false, $script = true, $includes = true, $variant = '') {
        if ($template = $this->getTemplate($GLOBALS['is_mobile'], 'body', $variant)) {
            $original_site = $GLOBALS['site'];
            $original_page = $GLOBALS['page'];
            $original_smarty = $GLOBALS['smarty'];
            $GLOBALS['site'] = $site = $this->getSite();
            $GLOBALS['page'] = $page = $this;
            $auth = $GLOBALS['auth'];
 
            // Jedes "fetch" muss ein auf die Site und Page eingestelltes Smarty Objekt für das Frontend verwenden
            $GLOBALS['smarty'] = $smarty = Ego_Smarty::createFrontend($site, array(
                'page' => $page
            ), true);
 
            // Skript für den Seitentyp einbinden (Sandbox)
            $require_script = function($filename) use ($site, $page, $smarty, $auth) {
                require($filename);
            };
            if ($script && ($filename = $site->getSiteFile($page->field['type'].'/index.php'))) {
                $require_script($filename);
            }
            if (!$outputfilter) {
                unset($smarty->_plugins['outputfilter'], $smarty->autoload_filters['output']);
            }
            $smarty->assign(array_merge(array(
                'site' => $site,
                'page' => $page
            ), $params));
 
            // Styles und Skripte einbinden
            $html = $includes ? $page->getHtml(false) : '';
            $html .= $smarty->fetch($template);
 
            $GLOBALS['site'] = $original_site;
            $GLOBALS['page'] = $original_page;
            $GLOBALS['smarty'] = $original_smarty;
        } else {
            $html = $this->field['content'];
        }
        return $html;
    }
 
    public function isValidSuffix($suffix) {
        $result = true;
        switch ($this->_site->site['type']) {
            case 'media':
                // Multimedia Dateien müssen immer auf .<image_type> enden.
                require_once 'base/Ego_Output.php';
                foreach (array_keys(Ego_Output::$convert_types) as $type) {
                    if ($suffix == ".$type" && $this->field['type'] == 'multimedia/image') {
                        // Automatische Umwandlung eines Bildes zulassen
                        return $result;
                    }
                }
                if (
                    in_array($this->field['type'], array('multimedia/file', 'multimedia/image'))
                    && !empty($this->extra['image_type'])
                    && '.' . $this->extra['image_type'] != $suffix
                ) {
                    $result = false;
                }
                break;
            case 'content':
                $key = 'suffixes';
                $suffixes = $this->_site->getCacheEntry($key);
                $type = $this->field['type'];
                if ($GLOBALS['is_mobile']) {
                    $type .= '@mobile';
                }
                $result = $suffixes[$type][$suffix];
                if (!is_bool($result)) {
                    $result = true;
                    // Nur wenn nicht .html und bestimmte <suffix> Ausnahmen, die in Seitentypen abgefragt werden.
                    // Existiert index.<suffix>.* nicht, muss body.<suffix>.* existieren.
                    if (
                        !in_array($suffix, array('.html', '.rss', '.ical', '.ics'))
                        && ($template = $this->getTemplate($GLOBALS['is_mobile'], 'index'))
                        && strpos(basename($template), "index{$suffix}.") !== 0
                        && ($template = $this->getTemplate($GLOBALS['is_mobile'], 'body'))
                        && strpos(basename($template), "body{$suffix}.") !== 0
                    ) {
                        $result = false;
                    }
                    $suffixes[$type][$suffix] = $result;
                    $this->_site->setCacheEntry($key, $suffixes);
                }
        }
        return $result;
    }
 
    public function getSocialNetworks() {
        if (in_array($this->field['type'], explode(',', $this->_site->admin['social']['types']))) {
            return $this->_site->getSocialNetworks();
        }
        return array();
    }
 
    public function compressVideo() {
        @set_time_limit(0);
 
        // Pfad zur Originaldatei (Multimedia)
        $media_dir = $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $this->_site->name;
        $dest = $media_dir . DIRECTORY_SEPARATOR . $this->getMediaFilename(true);
 
        // Auflösung der Originaldatei ermitteln
        $resolution = Ego_System::exec('ffprobe', array(
            '-v',
            'error',
            '-select_streams',
            'v:0',
            '-show_entries',
            'stream=height',
            '-of',
            'csv=s=x:p=0',
            $dest,
            '2>&1'
        ));
 
        // Mediapool Dateien entfernen
        $this->getMediapool()->clear();
 
        foreach (Ego_System::VIDEO_RESOLUTIONS as $height => $scale) {
            if ($resolution >= $height) {
                $tmp = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'video');
                $scale = preg_replace('/^\d+:/', '-2:', $scale); // Seitenverhältnis beibehalten
 
                // Verarbeitungsstatus verfolgen
                require_once 'base/Ego_Progress.php';
                $progress = new Ego_Progress('worker_' . $this->getIdentity() . '_' . $height . 'p');
                Ego_System::exec('ffmpeg', array(
                    '-i',
                    $dest,
                    '-vf',
                    'scale='.$scale,
                    '-f',
                    'mp4',
                    '-strict',
                    '-2',
                    '-y',
                    $tmp,
                    '-hide_banner',
                    '2>&1'
                ), $output);
 
                // Komprimierte Datei in den Mediapool der Originaldatei ablegen
                if (Ego_System::file_exists($tmp)) {
                    $this->getMediapool()->put($tmp, "{$height}p.mp4");
                    @unlink($tmp);
                }
 
                $progress->clear();
            }
        }
    }
 
    public function addResolution(int $width, int $height): void {
        @set_time_limit(0);
 
        // Pfad zur Originaldatei (Multimedia)
        $media_dir = $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $this->_site->name;
        $tmp = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'video');
        $scale = "$width:$height";
        $name = "{$width}_$height";
 
        // Verarbeitungsstatus verfolgen
        require_once 'base/Ego_Progress.php';
        $progress = new Ego_Progress('worker_' . $this->getIdentity() . '_' . $name);
        Ego_System::exec('ffmpeg', [
            '-i',
            $media_dir . DIRECTORY_SEPARATOR . $this->getMediaFilename(true),
            '-vf',
            'scale=' . $scale,
            '-f',
            'mp4',
            '-strict',
            '-2',
            '-y',
            $tmp,
            '-hide_banner',
            '2>&1'
        ], $output);
 
        // Komprimierte Datei in den Mediapool der Originaldatei ablegen
        if (Ego_System::file_exists($tmp)) {
            $this->getMediapool()->put($tmp, "$name.mp4");
            @unlink($tmp);
        }
 
        $progress->clear();
    }
 
    public function convertVideo() {
        $original_file = $GLOBALS['egotec_conf']['var_dir'] . "media/" . $this->_site->name . "/" . $this->getMediaFilename();
        $target_file = tempnam($GLOBALS['egotec_conf']['var_dir'] . 'tmp', 'convert');
 
        $log_file = $GLOBALS['egotec_conf']['tmp_dir'] . 'ffmpeg_log';
 
        Ego_System::exec(
            "ffmpeg",
            [
                "-y",
                "-i",
                $original_file,
                "-f mp4",
                $target_file,
                "2>&1 | tee",
                $log_file
            ]
        );
 
        $this->updateFile($target_file, $this->field['name'] . '_converted.mp4');
        if ($this->_site->admin['video']['compress']) {
            // Video komprimieren
            $this->compressVideo();
        }
 
        return true;
    }
 
    public function getThumbnail($width, $height = 0, $pool = '', $dir = '', $params = []) {
        // Pfad, in welchem das generierte Thumbnail zwischengespeichert wird
        $thumbnail = $GLOBALS['egotec_conf']['cachemedia_dir']
            . $this->_site->name . '/'
            . $this->_site->language . '/'
            . $this->field['id'] . '/'
            . strtotime($this->field['m_date']) . '/'
            . 'thumb_' . $width . 'x' . $height . '_' . md5(serialize([$pool, $dir, $params]));
 
        if (!Ego_System::file_exists($thumbnail)) {
            $file = '';
            $mime = '';
            if ($pool) {
                // Mediapool
                $info = $this->getMediapool()->get($pool, $dir);
                if (!empty($info) && !$info['quarantine']) {
                    $file = $info['file'];
                    $mime = $info['mime'];
                }
            } elseif (
                in_array($this->field['type'], ['multimedia/file', 'multimedia/image'])
                && !$this->extra['quarantine']
            ) {
                // Multimedia
                $file = $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $this->_site->name . '/' . $this->getMediaFilename();
                $mime = $this->extra['mime_type'];
            }
 
            // Pfad erzeugen, falls er nicht existiert
            $thumbnail_dir = dirname($thumbnail);
            if (!Ego_System::file_exists($thumbnail_dir)) {
                Ego_System::mkdir($thumbnail_dir);
            }
 
            // Thumbnail neu generieren
            if ($file && Ego_System::file_exists($file)) {
                if ($mime == 'application/pdf' || strpos($mime, 'image') === 0) {
                    // PDF, Animationen und Bilder können über "index" das erste Frame festlegen
                    require_once 'base/Ego_Image.php';
                    $image = new Ego_Image($file . '[' . ($params['index'] ?? 0) . ']');
                    if ($tmp = $image->thumbnail($width, $height, $params)) {
                        // Temporäres Thumbnail in den Cache verschieben
                        @rename($tmp, $thumbnail);
                    } else {
                        return null;
                    }
                } else {
                    // TODO Videos mit ffmpeg
                    return null;
                }
            }
        }
 
        // Die Thumbnail URL für die Verwendung im Template zurückliefern
        if ($params['get_url']) {
            return $this->getUrl(array_filter([
                'thumbnail' => implode('x', array_filter([$width, $height, (int) $params['index']])),
                'pool' => $pool,
                'dir' => $dir
            ]));
        }
 
        return $thumbnail;
    }
 
    public function replicate($method, ...$params) {
        if ($GLOBALS['__egotec_skip_replication'] === $method) {
            unset($GLOBALS['__egotec_skip_replication']);
        }
 
        // Nur wenn der Server ein Liveserver ist, die Live-Replikation aktiviert
        // und nur wenn die Replikation von einem anderen Server gestartet wurde
        if (
            $this->getSite()->admin['cluster']['replication']
            && $GLOBALS['egotec_conf']['liveserver']
            && !$_SERVER['HTTP_X_REPLICATION']
            && !$GLOBALS['__egotec_skip_replication']
        ) {
            require_once 'base/Ego_REST_Client.php';
 
            // Mediapool Methode erkennen
            if ($pool = (($parts = explode('.', $method, 2))[0] == 'pool')) {
                $method = $parts[1];
            }
 
            // Aktion über die Methode ermitteln
            $rest = parse_ini_file($GLOBALS['egotec_conf']['lib_dir'] . 'base/rest.ini', true);
            if (
                ($pool && ($conf = $rest['pool'][$method]))
                || ($conf = $rest['page'][$method])
            ) {
                [$action] = explode(':', $conf, 2);
            } else {
                // Die Methode wird nicht unterstützt
                return;
            }
 
            $replication = function() use ($method, $params, $action, $pool) {
                // Hole alle Cluster
                $clusters = Ego_System::getCluster($this->getSite());
 
                // Lege den Benutzer fest, in diesem Fall der Benutzer des Liveabgleichs
                $user_id = new_db_connection([
                    'table' => 'egotec_user',
                    'where' => 'username = :username',
                    'bind' => [
                        'username' => $this->getSite()->admin['live']['login']
                    ]
                ])->nextRecord()['user_id'];
                $user = new User_SQL($user_id);
                $path = implode('/', array_filter([
                    $this->getSite()->name,
                    $this->getSite()->language,
                    $this->field['id'],
                    $pool ? 'pool' : null,
                    $method
                ]));
 
                $convert_pages = function ($values) use (&$convert_pages) {
                    foreach ($values as $key => $value) {
                        if (is_array($value)) {
                            $values[$key] = $convert_pages($value);
                        } elseif (is_a($value, 'Page')) {
                            $values[$key] = '@identity:' . $value->getIdentity();
                        }
                    }
                    return $values;
                };
                $params = $convert_pages($params);
 
                // Daten und Uploads trennen
                $data = $files = [];
                foreach ($params as $key => $value) {
                    // Dateiupload erkennen
                    if (is_string($value) && strpos($value, '@file:') === 0) {
                        $data[$key] = '@file';
                        $files[] = new CURLFile($source = substr($value, 6));
                    } else {
                        $data[$key] = $value;
                    }
                }
 
                // Einzigartige IDs filtern und zwischenspeichern
                self::$nextIds = array_unique(self::$nextIds);
                $replicateIds = self::$nextIds;
 
                // Gehe alle Cluster durch
                foreach ($clusters as $cluster) {
                    if (!$cluster['oneway']) {
 
                        // Prüfen ob die IP mit einer der IPs im Array von "getDefaultLocalServerIps" übereinstimmt
                        // "getDefaultLocalServerIps": "127.0.0.1", "localhost", "::1", "0:0:0:0:0:0:0:1", $_SERVER['SERVER_ADDR']
                        $host = parse_url($cluster['url'], PHP_URL_HOST);
                        if (in_array(gethostbyname($host), Ego_System::getDefaultLocalServerIps())) {
                            // TODO Host zu IP auch wenn nur nach IPv6 aufgelöst werden kann
                            continue;
                        }
 
                        $url = rtrim($cluster['url'], '/') . '/rest/';
                        $client = new Ego_REST_Client($url, $user->field['user_id'], $user->extra['api_token']);
 
                        // Repliziere die Methode
                        $client->{strtolower($action)}(
                            $path,
                            array_merge(['@data' => json_encode($data)], $files),
                            [
                                "X-REPLICATION: $host",
                                "X-NEXT-IDS: " . implode(',', self::$nextIds)
                            ]
                        );
                    }
                }
 
                // ID an erster Stelle entfernen wenn mehr als eine ID im array
                if ((sizeof(self::$nextIds) > 1)) {
                    self::$nextIds = array_slice($replicateIds, 1);
                } else {
                    // Wenn nicht, array aus Zwischenspeicher übernehmen
                    self::$nextIds = $replicateIds;
                }
            };
 
            Ego_Queue::add($replication);
        }
    }
 
    public function isTemplate() {
        return $this->getAncestors(["where" => "type = '_template/list'"])->next() ? true : false;
    }
 
    public function isShortEditor() {
        $info = $this->getTypeInfo();
        if (isset($info['editor']['short'])) {
            return (bool) $info['editor']['short'];
        }
        return $this->_site->admin['editor']['short'] || $GLOBALS['egotec_conf']['editor']['short'];
    }
 
    public function getExtraValues(array $conf = [], bool $csv = false): array {
        if (count($conf) === 0) {
            $conf = $this->conf;
        }
 
        $extra_values = [];
 
        if (isset($conf['extra_fields']) && is_array($conf['extra_fields'])) {
            $src = $conf['extra_fields'];
 
            if ($csv && isset($conf['extra_fields']['csv']) && count($conf['extra_fields']['csv']) !== 0) {
                $src = $conf['extra_fields']['csv'];
            }
 
            // fields durchgehen (field, oder extra)
            foreach ($src as $field => $items) {
                if ($field === 'csv') {
                    continue;
                }
 
                // Alle Items in diesem field durchgehen
                foreach ($items as $item) {
                    $value = $this->$field[$item['value']];
 
                    // Arrays werden nicht ausgewertet
                    if (!is_array($value)) {
                        // Wenn modifier angegeben ist, diesen auswerten
                        if (isset($item['modifier'])) {
                            switch ($item['modifier']['type'] ?? null) {
                                // Datum formatieren
                                case 'date':
                                    $value = date($item['modifier']['format'], $item['modifier']['timestamp'] ? $value : strtotime($value));
                                    break;
 
                                // Werte prüfen/vergleichen
                                case 'assert':
                                    // Wenn ein Bild als Ergebnis des Vergleiches ausgegeben werden soll, immer vom Installationsverzeichnis ausgehen
                                    $true = $item['modifier']['true']['type'] === 'image'
                                        ? ($GLOBALS['egotec_conf']['url_dir'] . $item['modifier']['true']['value'])
                                        : $item['modifier']['true']['value'];
 
                                    $false = $item['modifier']['false']['type'] === 'image'
                                        ? ($GLOBALS['egotec_conf']['url_dir'] . $item['modifier']['false']['value'])
                                        : $item['modifier']['false']['value'];
 
                                    // Entweder prüfen, ob der Wert existiert (mode: exists), oder ob er einen bestimmten Wert hat (mode: compare)
                                    switch ($item['modifier']['mode'] ?? null) {
                                        case 'exists':
                                            if (isset($value) && !empty($value)) {
                                                $value = $true;
                                            } else {
                                                $value = $false;
                                            }
                                            break;
 
                                        case 'compare':
                                            $value = $value === $item['modifier']['value'] ? $true : $false;
                                            break;
 
                                        default:
                                            // unbekannter mode => ignorieren
                                    }
                                    break;
 
                                case 'function':
                                    if (
                                        isset($item['modifier']['function'])
                                        && isset($item['modifier']['file'])
                                        && Ego_System::file_exists($GLOBALS['egotec_conf']['var_dir'] . $item['modifier']['file'])
                                    ) {
                                        require_once ($GLOBALS['egotec_conf']['var_dir'] . $item['modifier']['file']);
 
                                        $value = call_user_func($item['modifier']['function'], $this);
                                    }
                                    break;
 
                                default:
                                    // unbekannter modifier => ignorieren
                            }
                        }
 
                        // Standardwert, wenn dieser angegeben ist
                        if ($item['default'] && empty($value)) {
                            $value = $item['default'];
                        }
 
                        // Das Template muss wissen, ob ein Bild angezeigt werden soll
                        if ($item['type'] === 'image') {
                            $extra_values[] = [
                                'value' => $value,
                                'image' => true,
                                'lightbox' => $item['lightbox']
                            ];
                        } else {
                            $extra_values[] = ['value' => $value];
                        }
                    } else if (isset($item['default'])) {
                        $extra_values[] = [
                            'value' => $item['default']
                        ];
                    }
                }
            }
        }
 
        return $extra_values;
    }
 
    public function exportChildrenAsCSV(array $ids, bool $downloadAll = false): void {
        require_once 'base/Ego_Output.php';
 
        $csv_file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'csv');
 
        // Daten für die CSV-Datei
        $data = [];
        // Selbst einstellbare Felder
        $extra_fields = [];
        // Kinder, die exportiert werden
        $children = [];
 
        $src = $this->conf['extra_fields'] ?? [];
 
        if (isset($src['csv'])) {
            $src = $src['csv'];
        }
 
        // Extrafelder aus conf.json auslesen
        if (is_array($src)) {
            foreach ($src as $field) {
                foreach ($field as $item) {
                    $extra_fields[] = $item['name'];
                }
            }
        }
 
        // Header setzen
        $data[0] = array_merge([
            $GLOBALS['auth']->translate('Name'),
            $GLOBALS['auth']->translate('Seitentyp'),
            $GLOBALS['auth']->translate('Ersteller'),
            $GLOBALS['auth']->translate('Erstellungsdatum'),
            $GLOBALS['auth']->translate('Letzter Bearbeiter'),
            $GLOBALS['auth']->translate('Bearbeitungsdatum'),
            $GLOBALS['auth']->translate('Freigabe von'),
            $GLOBALS['auth']->translate('Freigabe bis'),
            $GLOBALS['auth']->translate('Aktiv'),
        ], ($this->_site->admin['workflow']['enabled'] ? [$GLOBALS['auth']->translate('Ist im Workflow')] : []), $extra_fields);
 
        // Die ids der Seiten, die von den eingestellten Filtern getroffen wurden
        if (count($ids) > 0 && !$downloadAll) {
            foreach ($ids as $id) {
                $children[] = $this->_site->getPage((int) $id, ['inactive' => true]);
            }
        } else if ($downloadAll) {
            $children = $this->getDescendants([], ['inactive' => true]);
        } else {
            $children = $this->getChildren([], ['inactive' => true]);
        }
 
        // Daten aus den Kindern auslesen
        foreach ($children as $child) {
            // Workflowkopien ignorieren
            if ($child->isWorkflowCopy()) continue;
 
            $extra_values = [];
 
            // Eigentlichen Namen des Seitentyps auch ausgeben
            $typeInfo = $child->getTypeInfo();
 
            $a_user = $GLOBALS['auth']->translate('unbekannt');
            $c_user = $GLOBALS['auth']->translate('unbekannt');
 
            try {
                $a_user = (new User_SQL($child->field['a_user']))->getFullname(false);
            } catch (Exception $e) {/* Ignorieren */}
 
            try {
                $c_user = (new User_SQL($child->field['c_user']))->getFullname(false);
            } catch (Exception $e) {/* Ignorieren */}
 
            foreach ($child->getExtraValues($this->conf, true) as $value) {
                $extra_values[] = $value['value'];
            }
 
            // Daten in CSV-Array einfügen
            $data[] = array_merge([
                $child->field['name'],
                $typeInfo['title'] . ' (' . $child->field['type'] . ')',
                $a_user,
                $child->field['a_date'],
                $c_user,
                $child->field['c_date'],
                $child->field['release_from'] !== '0000-00-00 00:00:00' ? $child->field['release_from'] : '-',
                $child->field['release_until'] !== '0000-00-00 00:00:00' ? $child->field['release_until'] : '-',
                $child->isActive() ? $GLOBALS['auth']->translate('Ja') : $GLOBALS['auth']->translate('Nein'),
            ], $this->_site->admin['workflow']['enabled'] ? ([isset($child->extra['workflow_page']) ? $GLOBALS['auth']->translate('Ja') : $GLOBALS['auth']->translate('Nein')]) : [], $extra_values);
        }
 
        // CSV generieren
        Ego_System::createCSV($csv_file, $data);
 
        // CSV zum download anbieten
        $ego_output = new Ego_Output($csv_file);
        $ego_output->setName($this->field['title'] . '_Unterseiten.csv');
        $ego_output->download();
    }
 
    public function getAutoFill($autofill, $info = []) {
        $result = [];
 
        foreach ($autofill as $type => $data) {
            $result[$type]['value'] = preg_replace_callback('/%([a-z0-9_]+)/ims', function($match) use ($info) {
                $key = $match[1];
 
                if ($info['pool']) {
                    // Mediapool
                    switch ($key) {
                        case 'short':
                            $key = 'description';
                    }
 
                    $file = $this->getMediapool()->get($info['pool'], (string) $info['dir']);
                    $value = Ego_System::getAssocValue($file, $key);
                } else {
                    // Normale Seite
                    switch ($key) {
                        case 'description':
                            $key = 'short';
                    }
 
                    switch ($key) {
                        case 'name':
                        case 'title':
                        case 'short':
                            $value = Ego_System::getAssocValue($this->field, $key);
                            break;
 
                        default:
                            $value = Ego_System::getAssocValue($this->extra, $key);
                    }
                }
 
                // Bestimmte Werte immer modifizieren
                switch ($key) {
                    // Kurzbeschreibung immer als HTML ausgeben
                    case 'short':
                    case 'description':
                        if (!preg_match('/<[^>]+>/ms', $value)) {
                            $value = '<p>' . nl2br($value) .  '</p>';
                        }
                }
 
                return $value;
            }, $data['value']);
 
            $result[$type]['readonly'] = (bool) $data['readonly'];
        }
 
        return $result;
    }
 
    public function autoTranslate($param = [], $language = '', $diff = true, $force = false, $glossary = '', $source = '', $target = '', $original = true) {
        $language = $language ?: $this->_site->language;
 
        // Übersetzungen in diesem Durchlauf immer ohne Unterschiede prüfen.
        if (
            !empty($GLOBALS['__auto_translate_no_diff'])
            && (
                $GLOBALS['__auto_translate_no_diff'] === true
                || in_array($language, explode(',', (string) $GLOBALS['__auto_translate_no_diff']))
            )
        ) {
            $diff = false;
        }
 
        // Aktuelle Daten verwenden
        if (empty($param)) {
            $param = [
                'field' => $this->field,
                'extra' => $this->extra
            ];
        }
 
        // Zu verwendende Standardsprache
        $language_standard = !empty($param['extra']['language_standard'])
            ? $param['extra']['language_standard']
            : $this->extra['language_standard'];
        if (empty($language_standard)) {
            $language_standard = $this->_site->site['default_language'];
        }
 
        // Quell- und Zielsprache setzen
        $source = $source ?: $language_standard;
        $target = $target ?: $language;
 
        // Ist man selbst eine Sprachverknüpfung und wird DeepL verwendet, müssen alle Inhalte jetzt übersetzt werden
        if (
            Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'translate')
            && $_SERVER['HTTP_X_SOAP_CALL'] !== 'Replication' // Nicht beim Liveabgleich
            && (!Ego_System::isDevMode() || !empty($GLOBALS['egotec_conf']['dev']['deepl'])) // Nicht in Entwicklungsumgebungen
            && !$this->archiveOnly // Nicht für Zwischenspeicherungen
            && empty($param['field']['deleted']) // Nicht für gelöschte Seiten
            && !$this->isWorkflowCopy() // Nicht für Workflowkopien
            && !$this->isReleaseCopy() // Nicht für Freigabekopien
            && !$this->isClone() // Nicht für Klone
        ) {
            $auto_translate = function($check_diff) use (&$param, $language, $language_standard, $glossary, $source, $target, $original) {
                // Standardsprache zum Vergleichen ermitteln
                $GLOBALS['auto_translate_get_original_page'] = true;
                if ($original) {
                    $language_page = $this->getLanguagePage($language_standard, [
                        'inactive' => true,
                        'only_active' => false,
                        'auth_or' => '1=1',
                        'deleted_or' => '1=1'
                    ]);
                } else {
                    $language_page = $this;
                }
                unset($GLOBALS['auto_translate_get_original_page']);
                if (!$language_page) {
                    return;
                }
 
                // Nur bestimmte Felder übersetzen (Validierung überspringen)
                $fields = $this->getTranslationFields(false);
 
                foreach ($fields as $field => $keys) {
                    // Zwischenspeicher für zu übersetzende Texte
                    $result_keys = [];
                    $result_values = [];
 
                    foreach ($keys as $pattern) {
                        $results = Ego_System::getAssocValues($language_page->{$field}, $pattern);
                        if (is_array($results)) {
                            foreach ($results as $key => $value) {
                                if ($value !== null && !Ego_System::isEmptyContent($value)) {
                                    // Prüfen, ob sich der Inhalt geändert hat
                                    if (
                                        $check_diff
                                        && !empty($this->extra['auto_translated'])
                                        && $this->extra['auto_translated'][md5($key)] === md5(Ego_System::getAssocValue($language_page->{$field}, $key))
                                    ) {
                                        // Bisherige Übersetzung beibehalten
                                        Ego_System::setAssocValue($param[$field], $key, Ego_System::getAssocValue($this->{$field}, $key));
                                        $param['extra']['auto_translated'][md5($key)] = $this->extra['auto_translated'][md5($key)];
                                        continue;
                                    }
 
                                    $result_keys[] = $key;
                                    $result_values[] = $value;
                                }
                            }
                        }
                    }
 
                    // Alle gesammelten Texte übersetzen
                    if (sizeof($result_values) > 0) {
                        // Zwischenspeicher der zu übersetzenden Texte abarbeiten
                        require_once 'translate/Ego_DeepL.php';
                        $deepl = new Ego_DeepL($this->getSite());
                        $translated_values = $deepl->translate($source, $target, $result_values, $glossary);
 
                        if (sizeof($translated_values) != sizeof($result_values)) {
                            // Falls nicht dieselbe Menge zurückkommt, dann die bisherigen Übersetzungen behalten
                            foreach ($result_keys as $result_key) {
                                Ego_System::setAssocValue($param[$field], $result_key, Ego_System::getAssocValue($this->{$field}, $result_key));
                            }
                        } else {
                            // Übersetzte Texte speichern
                            foreach ($translated_values as $i => $translated_value) {
                                Ego_System::setAssocValue($param[$field], $result_keys[$i], $translated_value);
                                $param['extra']['auto_translated'][md5($result_keys[$i])] = md5($result_values[$i]);
                            }
                        }
                    }
                }
 
                // Alle URLs aus der Standardsprache in diesem Mandanten auf die aktuelle Sprache umstellen
                $recursive = function(&$value) use (&$recursive) {
                    if (is_array($value)) {
                        foreach ($value as &$v) {
                            $recursive($v);
                        }
                    } else {
                        $value = preg_replace_callback('/\/?index\.php\?[^ "]+/i', function($matches) {
                            if (
                                ($page = Ego_System::urltopage($matches[0]))
                                && $page->getSite()->name == $this->getSite()->name
                                && $page->getSite()->language == $this->extra['language_standard']
                                && $page->getLanguagePage($this->getSite()->language)
                            ) {
                                return str_replace('lang=' . $page->getSite()->language, 'lang=' . $this->getSite()->language, $matches[0]);
                            }
                            return $matches[0];
                        }, $value);
                    }
                };
                foreach (['field', 'extra'] as $field) {
                    $recursive($param[$field]);
                }
 
                // Übersetztes Extra-Feld serialisiert in das Standard-Feld übernehmen
                if (isset($param['field']) && isset($param['extra'])) {
                    $param['field']['extra'] = serialize($param['extra']);
                }
            };
 
            if (isset($param['extra'])) {
                if (
                    $force
                    || (
                        !empty($param['extra']['language_link'][$language])
                        && $param['extra']['language_link'][$language] == 2
                    )
                ) {
                    $auto_translate(!$force && $param['extra']['language_link'][$language] != $this->extra['language_link'][$language]
                        ? false // Wurde die Verknüpfung umgestellt, wird immer übersetzt
                        : $diff
                    );
                }
            } elseif (
                $force
                || (
                    !empty($this->extra['language_link'][$language])
                    && $this->extra['language_link'][$language] == 2
                )
            ) {
                $auto_translate($diff);
            }
        }
 
        return $param;
    }
 
    public function getTranslationFields($check = true) {
        if (
            $check
            && (
                !Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'translate')
                || (
                    empty($this->extra['language_link'][$this->_site->language])
                    || $this->extra['language_link'][$this->_site->language] == 1
                )
            )
        ) {
            return [
                'field' => [],
                'extra' => [],
                'title' => []
            ];
        }
 
        $conf = json_decode(Ego_System::file_get_contents($GLOBALS['egotec_conf']['lib_dir'] . 'translate/translate.json'), true);
 
        // Kundenspezifische Konfigurationen laden
        foreach ([
            'admin/translate.json',
            $this->field['type'] . '/admin/translate.json'
        ] as $path) {
            if ($json = $this->_site->getSiteFile($path)) {
                $custom_conf = json_decode(Ego_System::file_get_contents($json), true);
                if (!empty($custom_conf['merge'])) {
                    foreach ($custom_conf as $key => $value) {
                        if (is_array($value)) {
                            $custom_conf[$key] = array_merge($conf[$key] ?? [], $value);
                        }
                    }
                }
                $conf = $custom_conf;
            }
        }
 
        return [
            'field' => ['name', 'title', 'short', 'content'],
            'extra' => $conf['extra'] ?? [],
            'title' => $conf['title'] ?? []
        ];
    }
 
    public function getMandatoryFields() : array {
        $cache_key = 'mandatory'.md5(serialize(array($this->_site->name, $this->field['type'])));
        $mandatory = $this->_site->getCacheEntry($cache_key);
 
        if ($mandatory === null) {
            $mandatory = [];
 
            foreach ([
                $this->_site->getSiteFile('admin/mandatory.ini'),
                $this->_site->getSiteFile($this->field['type'] . '/admin/mandatory.ini')
            ] as $file) {
                if ($file) {
                    $conf = parse_ini_file($file, true);
 
                    // Alle Felder für diesen Seitentyp ignorieren
                    if (isset($conf['ignore_types']) && in_array($this->field['type'], explode(',', $conf['ignore_types']))) {
                        continue;
                    }
 
                    foreach ($conf as $key => $value) {
                        if (is_array($value)) {
                            if (isset($value['ignore_types']) && in_array($this->field['type'], explode(',', $value['ignore_types']))) {
                                // Dieses Feld für diesen Seitentyp ignorieren
                                continue;
                            }
 
                            $mandatory[$key] = $value;
                        }
                    }
                }
            }
 
            $this->_site->setCacheEntry($cache_key, $mandatory);
        }
 
        return $mandatory;
    }
 
    public function getAllEditUsers(): array {
        $users = [];
        $allUsers = $GLOBALS['auth']->user->getAllUsers(['auth_or' => '1=1']);
        $groupRoleRights = $this->getRightsArray()['edit'] ?? [];
        $userRights = $this->getUsersArray()['edit'] ?? [];
 
        foreach ($allUsers as $user) {
            if (empty($userRights) && empty($groupRoleRights)) {
                $users[] = $user;
                continue;
            }
 
            foreach ($userRights as $userRight) {
                if ($user->field['user_id'] === $userRight['user_id']) {
                    $users[] = $user;
                    continue 2;
                }
            }
 
            foreach ($groupRoleRights as $groupRoleRight) {
                if ($GLOBALS['auth']->hasPermission($groupRoleRight['group_id'], $groupRoleRight['role_id'], false, $user->field['user_id'])) {
                    $users[] = $user;
                    continue 2;
                }
            }
        }
 
        return $users;
    }
 
    public function getMetaData(): array {
        return [
            '@context' => 'https://schema.org',
            '@type' => 'WebPage',
            'name' => $this->field['title'],
            'description' => $this->extra['meta_descr'] ?: $this->field['short'],
            'mainEntityOfPage' => [
                '@type' => 'WebPage',
                '@id' => $this->getFrontendUrl(['return_absolute' => true])
            ]
        ];
    }
 
    public function pageHasContentTab ():bool {
        $site = $this->getSite();
        $navigation = [];
 
        $file_name = $site->getSiteFile($this->field['type'] . '/admin/navigation.ini');
        if (!$file_name) {
            $file_name = $GLOBALS['egotec_conf']['lib_dir'] . 'type/site/page/admin/navigation.ini';
        }
 
        if (!$file_name || !file_exists($file_name)) {
            $file_name = $GLOBALS['egotec_conf']['lib_dir'] . '/type/site/multimedia/category/admin/navigation.ini';
        }
 
        // Seitentyp Reiter
        if ($file_name = $site->getSiteFile($this->field['type'] . '/admin/navigation.ini')) {
            $this->mergeTabs($file_name, $navigation);
        } else {
            // Standard Reiter
            $this->mergeTabs($GLOBALS['egotec_conf']['lib_dir'] . 'type/site/page/admin/navigation.ini', $navigation);
        }
 
        // Mandanten Reiter
        if ($file_name = $site->getSiteFile('admin/navigation.ini', ['module', 'system', 'global'])) {
            $this->mergeTabs($file_name, $navigation);
        }
 
        // Globale Reiter (nur für Inhaltsmandanten)
        if ($site->globalAllowed()) {
            $file_name = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/navigation.ini';
 
            if ($site->site['type'] == 'content' && Ego_System::file_exists($file_name)) {
                $this->mergeTabs($file_name, $navigation);
            }
        }
 
        return !empty($navigation['content']);
    }
 
    public function mergeTabs(string $file_name, array &$navigation) {
        $navigation2 = parse_ini_file($file_name, true);
 
        foreach ($navigation2 as $key => $value) {
            if ($navigation[$key]) {
                // Der Reiter wurde bereits definiert und darf nicht überschrieben werden
                continue;
            }
 
            // ignore_sites = "site1,site2" beinhaltet alle Mandanten bei denen dieser Reiter nicht angezeigt wird
            if ($value['ignore_sites']) {
                $sites = explode(',', $value['ignore_sites']);
                if (in_array($this->getSite()->name, $sites)) {
                    continue;
                }
            }
 
            // ignore_types = "type1,type2" beinhaltet alle Seitentypen bei denen dieser Reiter nicht angezeigt wird
            if ($value['ignore_types']) {
                $types = explode(',', $value['ignore_types']);
 
                if (in_array($this->field['type'], $types)) {
                    continue;
                }
            }
 
            if (
                !empty($value['if'])
            ) {
                $invert = false;
                $regex = false;
 
                if (strpos($value['if'], '!') === 0) {
                    $invert = true;
                    $value['if'] = substr($value['if'], 1);
                }
 
                if (strpos($value['if'], '?') === 0) {
                    $regex = true;
                    $value['if'] = substr($value['if'], 1);
                }
 
                [$field_key, $value_to_test] = explode('=', $value['if'], 2);
                [$field, $key2] = explode('.', $field_key, 2);
 
                if (strpos($key2, '.') !== false) {
                    $test_value = Ego_System::getAssocValue($this->{$field}, $key2);
                } else {
                    $test_value = $this->{$field}[$key2];
                }
 
                if (
                    $regex
                    && (
                        (preg_match($value_to_test, $test_value) && !$invert) // Regex und nicht invertiert (?field.title=#Title#)
                        || (!preg_match($value_to_test, $test_value) && $invert) // Regex und invertiert (!?field.title=#Title#)
                    )
                ) {
                    $navigation[$key] = $value;
                } else if (
                    !$regex
                    && !empty($value_to_test)
                    && (
                        ($test_value == $value_to_test && !$invert) // Kein Regex und Prüfung, ob Feld einen bestimmten Wert hat (field.title=Title)
                        || ($test_value != $value_to_test && $invert) // Kein Regex und Prüfung, ob Feld einen bestimmten Wert nicht hat (!field.title=Title)
                    )
                ) {
                    $navigation[$key] = $value;
                } else if (
                    !$regex
                    && empty($value_to_test)
                    && (
                        (isset($test_value) && !$invert) // Kein Regex und Prüfung, ob Feld existiert (field.title)
                        || (empty($test_value) && $invert) // Kein Regex und Prüfung, ob Feld nicht existiert (!field.title)
                    )
                ) {
                    $navigation[$key] = $value;
                }
            } else {
                $navigation[$key] = $value;
            }
        }
    }
 
    public function getMessages($params = []) {
        $messages = [];
 
        // Die Seite ist gelöscht
        if ($this->field['deleted']) {
            $messages[] = [
                'type' => 'error',
                'text' => $GLOBALS['auth']->translate('Die Seite ist gelöscht.')
            ];
        }
 
        // Die Seite ist inaktiv
        if (!$this->field['deleted'] && !$this->isActive()) {
            $messages[] = [
                'type' => 'error',
                'text' => $GLOBALS['auth']->translate('Die Seite ist inaktiv.')
            ];
        }
 
        // Die Seite wird nicht auf den Liveserver übertragen
        if (!$GLOBALS['egotec_conf']['liveserver'] && $this->_site->hasLiveserver() && ($this->field['nav_hide']&2) == 2) {
            $messages[] = [
                'type' => 'warning',
                'text' => $GLOBALS['auth']->translate('Die Seite wird nicht auf den Liveserver übertragen.')
            ];
        }
 
        // Der ausgewählte Seitentyp stimmt nicht
        if (!empty($params['type']) && !in_array($this->field['type'], explode(',', $params['type']))) {
            $messages[] = [
                'type' => 'warning',
                'text' => $GLOBALS['auth']->translate('Der ausgewählte Seitentyp stimmt nicht.')
            ];
        }
 
        // Die Seite hat Ansichtsrechte
        if (!empty($params['view']) && $this->hasRightsOn('view')) {
            $messages[] = [
                'type' => 'warning',
                'text' => $GLOBALS['auth']->translate('Die Seite hat Ansichtsrechte.')
            ];
        }
 
        return $messages;
    }
}