Site.php

gehe zur Dokumentation dieser Datei

<?php
require_once('base/functions.php');
 
class Site_Exception extends Exception
{
    const  SITE_DOESNT_EXIST = 1; 
    const  LANG_DOESNT_EXIST = 2; 
    const  LANG_NOT_DELETABLE = 3; 
    const  MISSING_TEMPLATE = 4; 
}
 
class Site
{
    private  $_isDefault; 
    private  $_onlyActive; 
    private  $_time; 
    private  $_types; 
    private  $_typesFlat; 
    private  $_param = array(); 
    private  $_cachedMetaUrls = array(); 
    private  $_cache; 
    private  $_languages; 
    private  $_classes = array(); 
    private  $_root; 
    public  $name; 
    public  $site; 
    public  $admin; 
    public  $global = null; 
    public  $language; 
    public  $pageTable; 
    public  $skin = ''; 
    public  $theme = ''; 
    public  $rootId = 1; 
    public  $importFlag = false; 
    public  $conf = array(); 
    private  $virtualHosts = array(); 
    private  $mediaSites = array(); 
    private  $dataSites = array(); 
    private static  $confs = array(); 
    public function __call($function, $params) {
        if (strpos($function, '__') !== 0) {
            $magic_file = $GLOBALS['egotec_conf']['lib_dir'].'base/'.get_class($this).'.'.$function.'.php';
            if (file_exists($magic_file)) {
                require_once($magic_file);
                return call_user_func($function, $this, $params);
            } else {
                throw new Exception("Method 'Site.$function' not found");
            }
        }
    }
 
    private function _loadConfig($recalc = false) {
        if (!$recalc && $this->pageTable && isset(self::$confs[$this->pageTable])) {
            // Zwischengespeicherte Site Konfiguration verwenden
            $this->conf = self::$confs[$this->pageTable];
        } else {
            $this->conf = array();
 
            // Standard Mandanten Einstellungen laden
            $this->conf = Ego_System::getJSON($GLOBALS['egotec_conf']['lib_dir'] . '/admin/conf.json', $this->conf, true);
 
            // Mandanten spezifische Einstellungen laden
            if (Ego_System::file_exists($conf = $GLOBALS['egotec_conf']['site_dir'] . $this->name . '/admin/conf.json')) {
                $this->conf = Ego_System::getJSON($conf, $this->conf, true, ['plugins', 'toolbar', 'menubar']);
            }
 
            if (empty($this->conf['site'])) {
                // Abwärtskompatibilität: site Konfiguration aus conf.ini laden
                if (Ego_System::file_exists($GLOBALS['egotec_conf']['site_dir'] . $this->name . '/conf.ini')) {
                    $this->conf['site'] = parse_ini_file($GLOBALS['egotec_conf']['site_dir'] . $this->name . '/conf.ini', true);
                } else {
                    throw new Site_Exception("Site '$this->name' doesn't exist.", Site_Exception::SITE_DOESNT_EXIST);
                }
            }
 
            // Verwendete Sprache erkennen (wenn vorher kein setLanguage() stattgefunden hat, ist diese erst jetzt bekannt)
            if (!$this->language) {
                $this->language = $this->conf['site']['default_language'];
            }
            $this->pageTable = $this->name.'_'.$this->language;
 
            if (!$recalc && isset(self::$confs[$this->pageTable])) {
                // Sollte eine zwischengespeicherte Site Konfiguration nun gefunden werden können, dann diese verwenden
                $this->conf = self::$confs[$this->pageTable];
            } else {
                // ...ansonsten weitere Konfigurationen laden
 
                // Globale Einstellungen laden (werden nachträglich mit den site Einstellungen zusammengeführt, überschreiben diese aber nicht)
                if ($this->globalAllowed() && Ego_System::file_exists($conf = $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/conf.json')) {
                    $this->conf = Ego_System::getJSON($conf, $this->conf, true, ['plugins', 'toolbar', 'menubar'], false);
                }
 
                if (empty($this->conf['admin'])) {
                    // Abwärtskompatibilität: admin Konfiguration aus conf.ini laden
                    if (Ego_System::file_exists($GLOBALS['egotec_conf']['site_dir'] . $this->name . '/admin/conf.ini')) {
                        $this->conf['admin'] = parse_ini_file($GLOBALS['egotec_conf']['site_dir'] . $this->name . '/admin/conf.ini', true);
                    } else {
                        throw new Site_Exception("Site '$this->name' doesn't exist.", Site_Exception::SITE_DOESNT_EXIST);
                    }
                }
 
                $allowed_conf_keys = array('panel', 'navigation', 'layouts', 'blocks', 'page', 'notification');
 
                // Einstellungen der Designvorlage übernehmen
                if (!empty($this->conf['site']['theme'])) {
                    $theme_paths = array(
                        $GLOBALS['egotec_conf']['pub_dir'] . 'theme/' . $this->conf['site']['theme'] . '/site/admin/conf.json',
                        $this->globalAllowed() ? $GLOBALS['egotec_conf']['site_dir'] . '_global/admin/' . $this->conf['site']['theme'] . '.json' : ''
                    );
                    foreach ($theme_paths as $theme_path) {
                        if ($theme_path && Ego_System::file_exists($theme_path)) {
                            $theme_conf = Ego_System::getJSON($theme_path);
                            foreach ($allowed_conf_keys as $key) {
                                if (!empty($theme_conf[$key])) {
                                    if (empty($this->conf[$key])) {
                                        $this->conf[$key] = array();
                                    }
                                    $this->conf[$key] = array_replace_recursive($theme_conf[$key], $this->conf[$key]);
                                }
                            }
                        }
                    }
                }
 
                // Einstellungen des Systems übernehmen
                if (Ego_System::file_exists($system_path = $GLOBALS['egotec_conf']['var_dir'] . 'lib/admin/conf.json')) {
                    $system_conf = Ego_System::getJSON($system_path);
                    foreach ($allowed_conf_keys as $key) {
                        if (!empty($system_conf[$key])) {
                            if (empty($this->conf[$key])) {
                                $this->conf[$key] = array();
                            }
                            $this->conf[$key] = array_replace_recursive($system_conf[$key], $this->conf[$key]);
                        }
                    }
                }
 
                // Die Meta Daten werden nach Sprache gesetzt (abwärtskompatibel)
                $this->conf['site']['robots'] = $this->conf['site']['robots_' . $this->language] ?
                    $this->conf['site']['robots_' . $this->language] : ($this->conf['site']['robots_' . $this->conf['site']['default_language']] ?
                        $this->conf['site']['robots_' . $this->conf['site']['default_language']] :
                        $this->conf['site']['robots']);
                $this->conf['site']['keywords'] = $this->conf['site']['keywords_' . $this->language] ?
                    $this->conf['site']['keywords_' . $this->language] : ($this->conf['site']['keywords_' . $this->conf['site']['default_language']] ?
                        $this->conf['site']['keywords_' . $this->conf['site']['default_language']] :
                        $this->conf['site']['keywords']);
                $this->conf['site']['description'] = $this->conf['site']['description_' . $this->language] ?
                    $this->conf['site']['description_' . $this->language] : ($this->conf['site']['description_' . $this->conf['site']['default_language']] ?
                        $this->conf['site']['description_' . $this->conf['site']['default_language']] :
                        $this->conf['site']['description']);
 
                // Bei Multimedia-Seiten immer die Multimediatypen aktivieren
                if ($this->conf['site']['type'] == 'media') {
                    $this->conf['admin']['enabled_types']['multimedia'] = 1;
                    $this->conf['admin']['enabled_types']['multimedia/image'] = 1;
                    $this->conf['admin']['enabled_types']['multimedia/file'] = 1;
                    $this->conf['admin']['enabled_types']['multimedia/category'] = 1;
                }
 
                // Bezeichnung bestimmen
                if (!empty($this->conf['site']['title_' . $this->language])) {
                    $this->conf['site']['title'] = $this->conf['site']['title_' . $this->language];
                } elseif (!empty($this->conf['site']['title_' . $this->conf['site']['default_language']])) {
                    $this->conf['site']['title'] = $this->conf['site']['title_' . $this->conf['site']['default_language']];
                } elseif (empty($this->conf['site']['title'])) {
                    // Abwärtskompatibilität: Fallback auf Name wenn keine Bezeichnung existiert
                    $this->conf['site']['title'] = $this->name;
                }
 
                self::$confs[$this->pageTable] = &$this->conf;
            }
        }
 
        // Globale Konfigurationen laden
        $this->loadGlobalConfig();
 
        // Abwärtskompatibilität: site und admin als Referenz setzen
        $this->site = &$this->conf['site'];
        $this->admin = &$this->conf['admin'];
    }
 
    static function createSite($new_site) {
        Ego_System::mkdir($GLOBALS['egotec_conf']['site_dir'] . $new_site['name']);
 
        if ($new_site['type']=='media') {
            Ego_System::mkdir($GLOBALS['egotec_conf']['var_dir'] . 'media/' . $new_site['name']);
        }
 
        if (!empty($new_site['default_skin'])) {
            $skin_dir = $GLOBALS['egotec_conf']['skin_dir'] . $new_site['default_skin'];
 
            if (!Ego_System::file_exists($skin_dir)) {
                Ego_System::mkdir($skin_dir);
            }
        }
 
        copy($GLOBALS['egotec_conf']['lib_dir'] . 'template/site/conf.ini', $GLOBALS['egotec_conf']['site_dir'] . $new_site['name'] . '/conf.ini');
        Ego_System::mkdir($GLOBALS['egotec_conf']['site_dir'] . $new_site['name'] . '/admin');
        copy($GLOBALS['egotec_conf']['lib_dir'] . 'template/site/admin/conf.ini', $GLOBALS['egotec_conf']['site_dir'] . $new_site['name'] . '/admin/conf.ini');
 
        $newSite = new Site($new_site['name']);
 
        if ($new_site['lang']) {
            $new_site['default_language'] = $new_site['lang'];
            $new_site['languages'] = $new_site['lang'];
        }
 
        // Die Mandantenbezeichnung wird der Standardsprache zugeordnet
        if ($new_site['title'] && $new_site['default_language']) {
            $new_site['title_' . $new_site['default_language']] = $new_site['title'];
            unset($new_site['title']);
        }
 
        $rights = $new_site['rights'];
        unset($new_site['name'], $new_site['lang'], $new_site['rights']);
 
        $newSite->save($new_site);
        $newSite->createTables();
 
        require_once 'base/Ego_Search_Factory.php'; // Den Suchindex initialisieren.
 
        $search = Ego_Search_Factory::start($newSite->pageTable);
        $search->reset();
 
        $date = date('Y-m-d H:i:s');
        $field = [
            'id' => 1,
            'name' => 'Homepage',
            'title' => 'Homepage',
            'url' => '',
            'short' => '',
            'content' => 'This is the Homepage of a new site.',
            'extra' => serialize([]),
            'a_date' => $date,
            'c_date' => $date,
            'm_date' => $date,
            'a_user' => $GLOBALS['auth']->getId(),
            'c_user' => $GLOBALS['auth']->getId(),
            'm_user' => $GLOBALS['auth']->getId(),
            'type' => $new_site['type'] == 'media' ? 'multimedia/category' : ($new_site['type'] == 'data' ? 'data' : 'page'),
            'children_order' => 'type',
            'order_field' => 0,
            'nav_hide' => 0,
            'inactive' => 0,
            'cache' => 7,
            'release_from' => '0000-00-00 00:00:00',
            'release_until' => '0000-00-00 00:00:00',
            'workflow' => '',
            'workflow_state' => 0,
            'deleted' => 0
        ];
        $db = new_db_connection();
        $no_null_rights = trim(Auth::NO_NULL_RIGHTS, ',');
        $no_null_rights = explode(',', $no_null_rights);
        $insert_rights = [
            'set' => [
                'page_id' => 1,
                'group_id' => '*',
                'role_id' => '*'
            ]
        ];
 
        foreach ($newSite->getLanguages() as $lang) {
            $db->insert(['table' => $newSite->name . '_' . $lang, 'set' => $field]);
            $insert_rights['table'] = $newSite->name . '_' . $lang . '_rights';
 
            foreach ($no_null_rights as $no_null_right) {
                if ($no_null_right != 'live') {
                    $insert_rights['set']['perm'] = $no_null_right;
                    $db->insert($insert_rights);
                }
            }
        }
 
        /* Typenverwaltung setzen - #36701 */
        if ($newSite->site['type'] == 'media') {
            $newSite->save_admin([
                'enabled_types' => [
                    'multimedia' => 1,
                    'multimedia/image' => 1,
                    'multimedia/file' => 1,
                    'multimedia/category' => 1
                ]
            ]);
        } elseif($newSite->site['type'] == 'data') {
            $newSite->save_admin([
                'enabled_types' => [
                    'data' => 1,
                    'data/address' => 1,
                    'data/address/authority' => 1,
                    'data/address/building' => 1,
                    'data/address/department' => 1,
                    'data/address/person' => 1,
                    'data/events' => 1,
                    'data/events/organizer' => 1,
                    'data/events/venue' => 1,
                    'data/list' => 1,
                ]
            ]);
        } else {
            $newSite->save_admin([
                'enabled_types' => [
                    'page' => 1
                ]
            ]);
        }
 
        /* Bei neuen Mandanten gleich Rechte setzen - #66260 und #100979 */
        $default_group = is_array($rights) && $rights['group'] ? $rights['group'] : $GLOBALS['egotec_conf']['superuser']['group'];
        $default_role = is_array($rights) && $rights['role'] ? $rights['role'] : $GLOBALS['egotec_conf']['superuser']['role'];
 
        $right = $newSite->site['right'];
 
        foreach (['admin', 'translate', 'view', 'linkto', 'addclone', 'newclone', 'trashcan', 'stats', 'liveserver', 'site', 'skin', 'change_type', 'linkchecker', 'nousechecker', 'barriercheck'] as $type) {
            $right["{$type}_group_0"] = $default_group;
            $right["{$type}_role_0"] = $default_role;
        }
 
        $newSite->save_admin([
            'right' => $right
        ]);
 
        // Konfiguration aus dem internen Cache entfernen, da diese bereits geändert wurde, und neu laden
        self::$confs[$newSite->pageTable];
        $newSite = new Site($newSite->name);
 
        // Frontend Administration aktivieren, wenn es ein Layout gibt
        if ($newSite->getSkinFile('layout.tpl') || $newSite->getSkinFile('layout.html')) {
            $newSite->save_admin([
                'frontend_admin' => 1
            ]);
        }
 
        // Allgemeine Cache löschen
        $cache = Ego_System::getCache();
        $cache->reset();
 
        return $newSite;
    }
 
    function __construct($site_name = '', $language = '', $skin = '', $only_active = true, $time = '', $recalc = false)
    {
        $this->_onlyActive = $only_active;
        if ($_REQUEST['preview'] && $GLOBALS['auth'] && !$GLOBALS['auth']->isNobody()) {
            $this->_onlyActive = false;
        }
 
        $site_name = str_replace('/', '', $site_name); // #197684
        if (!file_exists($GLOBALS['egotec_conf']['site_dir'].$site_name))
        {
            throw new Site_Exception("Site '$site_name' doesn't exist.", Site_Exception::SITE_DOESNT_EXIST);
        }
        if ($site_name=='')
        { // Wenn keine Site übergeben wurde,
            $this->_isDefault = true;
            $site_name = $GLOBALS['egotec_conf']['default_site'];
        }
        $this->name = $site_name;
        $this->_loadConfig($recalc);
        if ($skin && in_array($skin, $this->getSkins()))
        {
            $this->skin = $skin;
        } else {
            $this->skin = $this->site['default_skin'];
        }
        $this->theme = (string) $this->site['theme'];
        $this->setLanguage($language);
        if ($GLOBALS['virtual_host_site'] && $GLOBALS['virtual_host_lang'] && $GLOBALS['virtual_host_site']==$this->name)
        { // Falls ein virtueller Host eingetragen ist,
            $this->site['default_language'] = $GLOBALS['virtual_host_lang'];
        }
        $this->setTime($time);
 
        /* Wenn diese Site keine Multimedia Site ist
         * oder keine Multimedia Site zugewiesen hat,
         * dann muss der Mediapool aktiviert sein. */
        if (
            !$this->hasMediaSite()
            && !$this->admin['mediapool']['active']
        ) {
            $this->save_admin(array(
                'mediapool' => array(
                    'active' => 1
                )
            ));
        }
    }
 
    public function setOnlyActive($b) {
        $this->_onlyActive = $b;
    }
 
    function setTime($time='')
    {
        if ($time)
        {
            $this->_time = $time;
        } else {
            $expire_time = $this->_cache->getExpire();
            $this->_time = date('Y-m-d H:i:s', (int)($expire_time ? $expire_time : time()));
        }
    }
 
    function setLanguage($language='')
    {
        // Alle zwischengespeicherten virtuellen Hosts leeren
        $this->virtualHosts = array();
 
        if ($language=='')
        {
            $language = $this->site['default_language'];
        }
        if (in_array($language, $this->getLanguages()))
        { // Die Sprache nur setzen, wenn Sie in der Site vorhanden ist.
            $new_page_table = $this->name.'_'.$language;
            if ($this->_param['auth_or'])
            { // Tabellenverweise anpassen.
                $this->_param['auth_or'] = str_replace($this->pageTable, $new_page_table, $this->_param['auth_or']);
            }
            if ($this->_param['deleted_or'])
            { // Tabellenverweise anpassen.
                $this->_param['deleted_or'] = str_replace($this->pageTable, $new_page_table, $this->_param['deleted_or']);
            }
            $this->language = $language;
            $this->pageTable = $new_page_table; // Der Name der Seitentabelle setzt sich aus dem Namen der Site und dem Sprachkürzel zusammen.
        } else {
            $this->language = $this->site['default_language'];
            $this->pageTable = $this->name.'_'.$this->site['default_language']; // Der Name der Seitentabelle setzt sich aus dem Namen der Site und dem Sprachkürzel zusammen.
            throw new Site_Exception('Die Sprache existiert nicht', Site_Exception::LANG_DOESNT_EXIST );
        }
 
        // Cache erzeugen.
        $path = $this->name.'/'.$this->language.'/';
        if ($this->_cache)
        {
            $this->_cache->setPath($this->name.'/'.$this->language.'/');
        } else {
 
            if (empty($GLOBALS["egotec_conf"]["cachemedia_dir"])) {
                $GLOBALS["egotec_conf"]["cachemedia_dir"] = $GLOBALS["egotec_conf"]["var_dir"]."cachemedia/";
            }
 
            switch ($GLOBALS['egotec_conf']['site_cache_type'])
            {
                case 'apcu':
                    require_once('base/Ego_Cache_apcu.php');
                    $this->_cache = new Ego_Cache_apcu($path);
                    break;
                case 'custom':
                    require_once($GLOBALS['egotec_conf']['var_dir'].'lib/Ego_Cache_custom.php');
                    $this->_cache = new Ego_Cache_custom($path);
                    break;
                default:
                    require_once('base/Ego_Cache_file.php');
                    $this->_cache = new Ego_Cache_file($path);
            }
        }
        if ($this->_cache->isExpired()) {
            $this->clearCache();
        }
        $this->_loadConfig();
    }
 
    function setRights($rights = array())
    {
        $this->_rights = array_unique($rights);
        $this->setParam(array('rights' => $this->_rights));
    }
 
    function addParam($param)
    {
        if ($this->_param)
        {
            $this->_param = array_merge($this->_param, $param);
        } else {
            $this->_param = $param;
        }
    }
 
    function setParam($param)
    {
        $this->_param = $param;
    }
 
    function getHash()
    {
        return md5(serialize($this->_param));
    }
 
    function getLanguages()
    {
        if (!$this->_languages) {
            $this->_languages = explode(',', $this->site['languages']);
        }
        return $this->_languages;
    }
 
    public function getSkins($theme = false) {
        $skins = explode(',', $this->site['skins']);
 
        // Das Standard Skin muss immer enthalten sein
        if (!in_array($this->site['default_skin'], $skins)) {
            $skins[] = $this->site['default_skin'];
        }
 
        // Designvorlage ebenfalls anführen
        if ($theme && !empty($this->theme)) {
            $skins[] = $this->theme;
        }
 
        return array_filter($skins);
    }
 
    function getPageId($name, $param = []) {
        $name = addslashes($name);
        $id_file = $GLOBALS['egotec_conf']['cache_dir'] . $this->name . '/_id/' . $name;
 
        if (file_exists($id_file)) { // Die ID aus dem Cache holen => keine DB Abfrage notwendig.
            return file_get_contents($id_file);
        } else if ($name) {
            $db = new_db_connection([ // Zunächst die ID über die Url bestimmen.
                'fields'    => 'id',
                'table'     => $this->pageTable,
                'where'     => 'url like :name',
                'bind'      => ['name' => $name]
            ]);
 
            if ($db->nextRecord()) {
                return (int) $db->Record['id'];
            } else { // Falls über die Url keine ID gefunden wurde, dann wird die ID über den Namen bestimmt-
                $db->select([
                    'fields' => 'id',
                    'table' => $this->pageTable,
                    'where' => 'name like :name',
                    'bind' => ['name' => $name],
                    'order' => 'id asc', // Damit eine Seite, die später mit dem gleichen Namen eingefügt wurde, nicht gefunden wird.
                    'limit' => '1'
                ]);
 
                if ($db->nextRecord()) {
                    return (int) $db->Record['id'];
                }
            }
 
            return 0;
        } else {
            return $this->rootId;
        }
    }
 
    public function getOnlyActive() {
        return $this->_onlyActive;
    }
 
    public function getTime() {
        return $this->_time;
    }
 
    function getPages($query=array(), $param = array())
    {
        if (is_array($param))
        {
            $param = array_merge($this->_param, $param);
        } else {
            $param = $this->_param;
        }
        if (!$param['lang'])
        { // Wird keine Sprache übergeben, was meist der Fall ist, dann wird die Sprache des $site Objekts verwendet.
            $param['lang'] = $this->language;
            $site = $this;
        } else {
            $site = clone $this;
            try {
                $site->setLanguage($param['lang']);
            } catch (Site_Exception $e) {
                if ($e->getCode() == Site_Exception::LANG_DOESNT_EXIST) {
                    return new Page_Iterator($this);
                }
            }
        }
        $page_table = $site->name.'_'.$param['lang'];
 
        if (is_string($query)||is_bool($query))
        { // Beim Aufruf über Smarty liegt query als string in der Form array("where" => "...") vor
            egotec_error_log('$query wurde als String übergeben Query: '.$query);
            eval ("\$query = $query;");
        }
        if (trim($query['where']))
        { // Um weitere Bedingungen anfügen zu können, müssen die übergebenen Bedingungen geklammert werden.
            $query['where'] = '('.$query['where'].')';
        } else
        {
            $query['where'] = '1=1';
        }
 
        // "fields2" als Array verwenden
        if (!isset($query['fields2'])) {
            $query['fields2'] = [];
        } elseif (is_string($query['fields2'])) {
            $query['fields2'] = [$query['fields2']];
        }
 
        if (($site->getOnlyActive() && !$param['inactive']) || $param['only_active'])
        { // Die ursprüngliche Zeile $query.=... gab beim Aufruf über Smarty eine Fehlermeldung
            $query['where'] = $query['where']."
                    and $page_table.inactive=0
                ";
            $query['where'] = $query['where']."
                    and ($page_table.release_until='0000-00-00 00:00:00' or $page_table.release_until >= '".$site->getTime()."')
                    and ($page_table.release_from='0000-00-00 00:00:00' or $page_table.release_from < '".$site->getTime()."')
                ";
        } elseif (($_REQUEST['preview'] || $GLOBALS['frontend_admin']) && empty($param['expired'])) {
            // In der Vorschau/Frontend Administration werden inaktive Seiten durch das Freigabe bis Datum nicht angezeigt
            $query['where'] = $query['where']."
                    and ($page_table.release_until='0000-00-00 00:00:00' or $page_table.release_until >= '".$site->getTime()."')
                ";
        }
 
        // Bitand ermitteln
        $bitand_query = $this->getBitandQuery($param, $page_table);
        if (!empty($bitand_query) && !empty($query['fields']) && strpos($query['fields'], 'nav_hide') === false) {
            $query['fields'] .= ','.$page_table.'.nav_hide';
        }
        $query['bitand'] = $bitand_query;
 
        if ((integer)$param['deleted']>=0)
        { // Gelöschte Seiten ausblenden.
            $query['where'] = $query['where'].' AND ('.$page_table.'.deleted='.
                (integer)$param['deleted'].($param['deleted_or']?' OR '.$param['deleted_or']:'').')';
        }
        $query['table'] = ($query['table']?$query['table'].',':'').$page_table;
        if (!isset($param['rights']))
        {
            $param['rights'] = array('view');
        }
        if (!isset($query['fields']))
        {
            $query['fields'] = $page_table.'.*';
        }
        if ($param['where'])
        {
            $query['where'] = ($query['where']?$query['where'].' AND ':'').'('.$param['where'].')';
        }
        if ($param['auth_or']!='1=1')
        {
            $query = $GLOBALS['auth']->getPageTableQuery($page_table, $param['rights'], $query, $param);
        }
        if ($param['fulltext'] || $param['extra'] || $param['filter'])
        {
            require_once('base/Ego_Search_Factory.php');
            try {
                $search = Ego_Search_Factory::start($site->pageTable, array_merge(['only_active' => $site->getOnlyActive()], $param));
            } catch (Exception $e) {
                // Ist die Suche nicht erreichbar, darf es hier zu keinem Abbruch kommen
                $search = null;
            }
 
            if ($search) {
                if ($param['extra']) {
                    // Extra Suche durchführen
                    if (isset($param['extra_bind'])) {
                        // Fallback für extra_bind, da extra-bind nicht als Smarty Parameter übergeben werden kann
                        $param['extra-bind'] = $param['extra_bind'];
                    }
                    $search->setExtraQuery($param['extra'], (array) $param['extra-bind']);
                }
 
                if ($query['where'] && preg_match_all('/\W'.$this->pageTable.'\.id in \‍(([0-9, ]+)\‍)/i', $query['where'], $matches)) {
                    $query['id_list'] = [];
                    foreach ($matches[1] as $match) {
                        $query['id_list'] = array_merge($query['id_list'], array_map('trim', explode(',', $match)));
                    }
                }
 
                if ($GLOBALS['egotec_conf']['search_engine'] == 'sql') {
                    $query = $search->search((string) $param['fulltext'], $site->pageTable.'.id', $query, true);
                } elseif ($GLOBALS['egotec_conf']['search_engine'] == 'lucene' || $GLOBALS['egotec_conf']['search_engine'] == 'elastic') {
                    $query = $search->search((string) $param['fulltext'], $site->pageTable.'.id', $query, $param['filter'], (bool) $param['fuzzy']);
                    if ($GLOBALS['egotec_conf']['search_engine'] == 'elastic') {
                        // Limit wird bereits von Elasticsearch verarbeitet
                        unset($query['limit']);
                    }
                } else {
                    $query = $search->search((string) $param['fulltext'], $site->pageTable.'.id', $query);
                }
                $query['distinct'] = true;
            } else {
                // Ist die Suche nicht erreichbar, wird nichts zurückgeliefert
                require_once('base/Page_Iterator.php');
                return new Page_Iterator($site);
            }
        }
        if ($param['without_types'])
        {
            $query['where'].= ' AND '.$page_table.'.type NOT IN (\''.str_replace(",","','",$param['without_types']).'\')';
        }
        if ($param['search_keywords'])
        {
            if ($this->admin['keyword_register_own_site']) {
                // Neues Schlagwortregister
                $page_ids = [];
                if (is_numeric($param['search_keywords'])) {
                    $keywords_query = [
                        'where' => "type = '_keywords/entry' AND id = :id",
                        'bind' => [
                            'id' => $param['search_keywords']
                        ]
                    ];
                } else {
                    $keywords_query = [
                        'where' => "type = '_keywords/entry' AND name = :name",
                        'bind' => [
                            'name' => $param['search_keywords']
                        ]
                    ];
                }
                $keywords = $this->getPages(array_merge([
                    'fields' => 'id, type',
                ], $keywords_query));
                foreach ($keywords as $keyword) {
                    $children = $keyword->getChildren([
                        'fields' => 'id, type',
                        'where' => "type != '_keywords/entry'"
                    ]);
                    foreach ($children as $child) {
                        $page_ids[] = $child->field['id'];
                    }
                }
                return $this->getPages([
                    'where' => "id IN ('" . implode("', '", $page_ids) . "')"
                ]);
            } else {
                // Altes Schlagwortregister
                if ($site->admin['keywords']['site'])
                {
                    $keywords_tbl = $site->admin['keywords']['site'].'_'.$site->language;
                } else
                {
                    $keywords_tbl = $site->pageTable;
                }
                require_once('base/Ego_Search_Sql.php');
                $search = new Ego_Search_Sql($keywords_tbl, '_keywords');
                $query = $search->search(
                    $param['search_keywords'],
                    $site->pageTable.'.id',
                    $query,
                    true,
                    'page_id',
                    'word',
                    '',
                    $site->name.'_keywords_rel.page_id',
                    ','.$site->name.'_keywords_rel',
                    $site->name.'_keywords_rel.keyword_id='.$keywords_tbl.'_keywords.id',
                    'SELECT SUM(page_id/page_id) FROM '.$keywords_tbl.'_keywords,'.$site->name.'_keywords_rel WHERE '.
                    $site->name.'_keywords_rel.keyword_id='.$keywords_tbl.'_keywords.id',
                    true
                );
                $query['distinct'] = true;
            }
        }
        if ($query['andor'])
        {
            $and = array();
            foreach ($query['andor'] as $ors)
            {
                $and[] = '('.join(') OR (', $ors).')';
            }
            $query['where'].= "\n AND (".join(") AND (", $and).')';
            unset($query['andor']);
        }
        if ($query['and'])
        {
            $query['where'].= "\n AND ".join(' AND ', $query['and']);
            unset($query['and']);
        }
        if ($query['or'])
        {
            $query['where'].= "\n AND ( (".join(")\n OR (", $query['or']).') )';
            unset($query['or']);
        }
        if ($query['score'])
        {
            $query['fields2'][] = '(LN(('.join(') + (', $query['score']).'))+1) AS score';
            unset($query['score']);
        }
        if ($param['has_children'])
        {
            $has_children_where = $param['has_children_where'] ? ' AND ('.$param['has_children_where'].') ' : '';
            if ((integer)$param['deleted']>=0)
            { // Gelöschte Seiten ausblenden.
                $has_children_where.= ' AND (has_table.deleted='.
                    (integer)$param['deleted'].($param['deleted_or']?' OR '.$param['deleted_or']:'').')';
            }
            if (($site->getOnlyActive() && !$param['inactive']) || $param['only_active'])
            { // Die ursprüngliche Zeile $query.=... gab beim Aufruf über Smarty eine Fehlermeldung
                $has_children_where.= ' AND has_table.inactive=0'.
                    ' AND (has_table.release_until=\'0000-00-00 00:00:00\' or has_table.release_until>=\''.$site->getTime().'\')'.
                    ' AND (has_table.release_from=\'0000-00-00 00:00:00\' or has_table.release_from<\''.$site->getTime().'\')';
            } elseif (($_REQUEST['preview'] || $GLOBALS['frontend_admin']) && empty($param['expired'])) {
                // In der Vorschau/Frontend Administration werden inaktive Seiten durch das Freigabe bis Datum nicht angezeigt
                $has_children_where.= ' AND (has_table.release_until=\'0000-00-00 00:00:00\' or has_table.release_until>=\''.$site->getTime().'\')';
            }
 
            /* Bitand für has_children ermitteln
             * (die pageTable muss mit "has_table" ersetzt werden, damit die bitand Anweisungen auch auf den Sub-Select angewendet werden)
             */
            $query['field_as_bitand']['has_children'] = array_map(function($value) {
                $value[0] = str_replace($this->pageTable . '.', 'has_table.', $value[0]);
                return $value;
            }, $bitand_query);
 
            $children_query = [
                'page_table' => 'has_table',
                'where' => $page_table .'.id='.$page_table.'_children.page_id'.
                    ' AND '.$page_table.'_children.child=has_table.id'.
                    $has_children_where
            ];
            $query['distinct']  = true;
 
            if ($param['auth_or']!='1=1')
            {
                $children_query = $GLOBALS['auth']->getPageTableQuery($page_table, $param['rights'], $children_query, $param);
            }
            $query['field_as']['has_children'] = 'SELECT '.($param['children_count']===false?'DISTINCT 1':'count(DISTINCT child)').
                ' FROM '.$page_table.'_children,'.$page_table.' has_table'.
                ($children_query['join']?' LEFT JOIN '.(is_array($children_query['join'])?
                        implode(' LEFT JOIN ', $children_query['join']):$children_query['join']):'').
                ' WHERE '.$children_query['where'];
            if ($param['children_count'] === false) {
                $query['field_as_limit']['has_children'] = '0,1';
            }
        }
        if ($param['multi_parents'])
        {
            $multi_where = '';
            if ((integer)$param['deleted']>=0)
            { // Gelöschte Seiten ausblenden.
                $multi_where.= ' AND (multi_table.deleted='.
                    (integer)$param['deleted'].($param['deleted_or']?' OR '.$param['deleted_or']:'').')';
            }
            if (($site->getOnlyActive() && !$param['inactive']) || $param['only_active'])
            { // Die ursprüngliche Zeile $query.=... gab beim Aufruf über Smarty eine Fehlermeldung
                $multi_where.= ' AND multi_table.inactive=0'.
                    ' AND (multi_table.release_until=\'0000-00-00 00:00:00\' or multi_table.release_until>=\''.$site->getTime().'\')'.
                    ' AND (multi_table.release_from=\'0000-00-00 00:00:00\' or multi_table.release_from<\''.$site->getTime().'\')';
            } elseif (($_REQUEST['preview'] || $GLOBALS['frontend_admin']) && empty($param['expired'])) {
                // In der Vorschau/Frontend Administration werden inaktive Seiten durch das Freigabe bis Datum nicht angezeigt
                $multi_where.= ' AND (multi_table.release_until=\'0000-00-00 00:00:00\' or multi_table.release_until>=\''.$site->getTime().'\')';
            }
 
            // Bitand für multi_parents ermitteln
            $query['field_as_bitand']['multi_parents'] = $bitand_query;
 
            $query['field_as']['multi_parents'] = 'SELECT count(page_id)-1'.
                ' FROM '.$page_table.'_children,'.$page_table.' multi_table'.
                ' WHERE '.$page_table.'.id=child'.
                ' AND '.$page_table.'_children.page_id=multi_table.id'.
                $multi_where;
            $query['distinct']  = true;
        }
        require_once('base/Page_Iterator.php');
        if ($GLOBALS['egotec_conf']['pages_cache'] && !$param['no_cache'])
        {
            return new Page_Iterator($site, new_db_connection($query, $site->getCache()));
        } else {
            return new Page_Iterator($site, new_db_connection($query));
        }
    }
 
    private function getBitandQuery($param, $page_table = '') {
        $query = array();
        if (!$page_table) {
            $page_table = $this->pageTable;
        }
        if (
            !isset($param['sitemap'])
            && $param['fulltext']
            && !$GLOBALS['admin_area']
        ) {
            // In der Frontend Suche standardmäßig nur Seiten finden, die auch in der Sitemap angezeigt werden
            $param['sitemap'] = true;
        }
        if ($param['no_nav_hide'])
        { // Nur Seiten, die in der Navigation angezeigt werden (nav_hide&1=0)
            $query[] = array($page_table.'.nav_hide', 1, 0);
            $param['sitemap'] = true; // Außerdem nur Seiten, die in der Sitemap angezeigt werden
        }
        if ($param['no_intranet'])
        { // Nur Seiten, die auf den Liveserver übertragen werden (nav_hide&2=0)
            $query[] = array($page_table.'.nav_hide', 2, 0);
        }
        if ($param['intranet'])
        { // Nur Seiten, die nur im Intranet angezeigt werden (nav_hide&2=2)
            $query[] = array($page_table.'.nav_hide', 2, 2);
        }
        if ($param['search'])
        { // Nur Seiten, die nicht von der Suche ausgeschlossen werden (nav_hide&4=0)
            $query[] = array($page_table.'.nav_hide', 4, 0);
        }
        if ($param['sitemap'] && (!$GLOBALS['egotec_conf']['show_hidden_sitemap'] || !$GLOBALS['admin_area']))
        { // Nur Seiten, die in der Sitemap angezeigt werden (nav_hide&8=0)
            $query[] = array($page_table.'.nav_hide', 8, 0);
        }
        if ($param['nouse'])
        { // Nur Seiten, die im Verwendungsnachweis berücksichtigt werden sollen (nav_hide&16=0)
            $query[] = array($page_table.'.nav_hide', 16, 0);
        }
        if (isset($param['flag0']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&32=0)
            $query[] = array($page_table.'.nav_hide', 32, $param['flag0']?32:0);
        }
        if (isset($param['flag1']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&64=0)
            $query[] = array($page_table.'.nav_hide', 64, $param['flag1']?64:0);
        }
        if (isset($param['flag2']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&128=0)
            $query[] = array($page_table.'.nav_hide', 128, $param['flag2']?128:0);
        }
        if (isset($param['flag3']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&256=0)
            $query[] = array($page_table.'.nav_hide', 256, $param['flag3']?256:0);
        }
        if (isset($param['flag4']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&512=0)
            $query[] = array($page_table.'.nav_hide', 512, $param['flag4']?512:0);
        }
        if (isset($param['flag5']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&1024=0)
            $query[] = array($page_table.'.nav_hide', 1024, $param['flag5']?1024:0);
        }
        if (isset($param['flag6']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&2048=0)
            $query[] = array($page_table.'.nav_hide', 2048, $param['flag6']?2048:0);
        }
        if (isset($param['flag7']))
        { // Weitere Flag für offene Anwendungsfälle (nav_hide&4096=0)
            $query[] = array($page_table.'.nav_hide', 4096, $param['flag7']?4096:0);
        }
 
        return $query;
    }
 
    function getLostPages($deleted = -1)
    {
        /* Verlorene Seiten sind:
         * 1. Seiten ohne Elternseite
         * 2. Seiten die als Elternseite nur Schlagwörter haben (aber selbst kein Schlagwort sind) */
        return $this->getPages(
            array(
                'join' => array($this->pageTable.'_children ON child = id'),
                'where' => "id != {$this->rootId} AND (child IS NULL OR (type != '_keywords/entry' AND id IN (SELECT child FROM {$this->pageTable}_children INNER JOIN {$this->pageTable} ON page_id = id WHERE type = '_keywords/entry') AND id NOT IN (SELECT child FROM {$this->pageTable}_children INNER JOIN {$this->pageTable} ON page_id = id WHERE type != '_keywords/entry')))"
            ),
            array(
                'deleted' => $deleted,
                'auth_or' => '1=1'
            )
        );
    }
 
    function getPage($id, $param = []) {
        if (
            $id == ''
            || !is_numeric($id)
        ) {
            return null;
        }
 
        $cache_key = md5(serialize([$this->language, $param]));
 
        if ($id == $this->rootId && $page = $this->_root[$cache_key]) {
            return $page;
        }
 
        if (is_numeric($_REQUEST['id']) && $id == $_REQUEST['id']) {
            // Falls möglich, die aktuelle abgelaufene Seite anzeigen
            $param['expired'] = true;
        }
 
        if ($param['original']) {
            // Die originale Seite holen (für "Speichern und Veröffentlichen")
            $GLOBALS['public_save_get_original_page'] = true;
            unset($param['original']);
        }
 
        $pages = $this->getPages([
                'fields' => $param['fields'],
                'where' => 'id=:id',
                'bind'  => ['id' => (int) $id]
            ],
            $param
        );
 
        $page = $pages->nextPage();
        unset($GLOBALS['public_save_get_original_page']);
 
        if ($id == $this->rootId) { // Die root Seite cachen, da auf diese oft zugefriffen wird.
            $this->_root[$cache_key] = $page;
        }
 
        return $page;
    }
 
    function getRoot($param = array())
    {
        return $this->getPage($this->rootId, $param);
    }
 
    function getErrorPage()
    {
        $GLOBALS['_SERVER']['REDIRECT_STATUS'] = '404';
        if (!($page = $this->getPage($this->site['error_id'] ? $this->site['error_id'] : $this->rootId))) {
            // Falls die eingestellte Fehlerseite nicht erreichbar ist, wird die Startseite verwendet
            $page = $this->getRoot();
        }
        return $page;
    }
 
    function getUrl($param, $page = null)
    {
        if (!$this->_onlyActive && !isset($param['nonactive']))
        { // Auch inaktive Seiten anzeigen.
            $param['nonactive'] = true;
        }
        if (isset($param['nonactive']) && !$param['nonactive'])
        {
            unset($param['nonactive']);
        }
        if (!isset($param['lang']))
        {
            $param['lang'] = $this->language;
        }
        if (!isset($param['skin']) && $this->skin!=$this->site['default_skin'])
        {
            $param['skin'] = $this->skin;
        }
        if (!isset($param['site']))
        {
            $param['site'] = $this->name;
        }
 
        // Alphabetische Reihenfolge der URL Parameter
        ksort($param);
 
        if ($param['get_frontend_url']) {
            // Im Adminbereich eine sprechende URL ermitteln
            return get_url('index.php', $param, $page, true, 2);
        }
        return get_url('index.php', $param, $page);
    }
 
    function getPageUrl($page_id, $params = array(), $page = null)
    {
        return $page_id?$this->getUrl(array_merge(array('id' => $page_id), $params), $page):$this->getErrorPage();
    }
 
    function getMediaSite($lang = '') {
        if (
            $this->site['type'] != 'media'
            && empty($this->site['media'])
        ) {
            return null;
        }
 
        if ($lang == '') {
            $lang = $this->language;
        }
 
        if (isset($this->mediaSites[$lang])) {
            return $this->mediaSites[$lang];
        }
 
        if ($this->site['type'] == 'media') {
            $media_site = $this;
        } else {
            $media_site = new Site($this->site['media'], '', '', $this->_onlyActive);
            $media_site->setParam($this->_param);
        }
 
        // Prüfen, ob die aktuelle Sprache auch im Multimedia Mandanten existiert
        if (
            in_array($lang, $media_site->getLanguages())
            && $lang != $media_site->language
        ) {
            $media_site->setLanguage($lang);
        }
 
        return $this->mediaSites[$lang] = $media_site;
    }
 
    public function getDataSite($lang = '') {
        if (
            $this->site['type'] !== 'data'
            && empty($this->site['data'])
        ) {
            return null;
        }
 
        if ($lang == '') {
            $lang = $this->language;
        }
 
        if (isset($this->dataSites[$lang])) {
            return $this->dataSites[$lang];
        }
 
        if ($this->site['type'] == 'data') {
            $data_site = $this;
        } else {
            $data_site = new Site($this->site['data'], '', '', $this->_onlyActive);
            $data_site->setParam($this->_param);
        }
 
        // Prüfen, ob die aktuelle Sprache auch im Multimedia Mandanten existiert
        if (
            in_array($lang, $data_site->getLanguages())
            && $lang != $data_site->language
        ) {
            $data_site->setLanguage($lang);
        }
 
        return $this->dataSites[$lang] = $data_site;
    }
 
    public function hasMediaSite() {
        return ($this->site['type'] == 'media' || !empty($this->site['media']));
    }
 
    public function hasDataSite() {
        return ($this->site['type'] === 'data' || !empty($this->site['data']));
    }
 
    public function getFirstSite($type) {
        $site = null;
        $method = 'get' . ucfirst($type) .'Site';
        if (method_exists($this, $method) && ($connected_site = $this->{$method}()) && $connected_site->hasRight('desktop')) {
            $site = $connected_site;
        } else {
            foreach (Ego_System::getAllSites($GLOBALS['auth']->user->field['id'], 'desktop', false, $type) as $connected_site) {
                $site = $connected_site;
                break;
            }
        }
        return $site;
    }
 
    function getMediaUrl($id, $param = array(), $url_param = array())
    {
        if ($param['no_suffix'])
        {
            $url_param['no_suffix'] = $param['no_suffix'];
            unset($param['no_suffix']);
        }
        return $this->getMediaSite()->getPage($id, $param)->getUrl($url_param);
    }
 
    function clearCache($id=0, $all_languages = false)
    {
        if ($all_languages) {
            // Cache für alle Sprachen ungültig setzen
            $site = clone $this;
            foreach ($site->getLanguages() as $lang) {
                $site->setLanguage($lang);
                $site->clearCache($id);
            }
            return;
        }
 
        $language = $this->language;
        $pageTable = $this->name.'_'.$language;
        if (!file_exists($GLOBALS['egotec_conf']['log_dir'].$this->name.'_'.$language))
        {
            Ego_System::mkdir($GLOBALS['egotec_conf']['log_dir'].$this->name.'_'.$language, 0777, true);
        }
 
        if ($id)
        { // Bei Bildern wird nicht der komplette Cache, sondern nur das aktuelle Bild gelöscht
            $cache_path = $GLOBALS['egotec_conf']['cachemedia_dir'].$this->name.'/'.$language.'/';
            Ego_System::deldir($cache_path.$id, true);
        }
 
        // Cache, Lebensdauer einstellen nun immer 24h
        $new_cache_lifetime = 86400;
 
        $cache_expire = date('Y-m-d H:i:s', time()+$new_cache_lifetime);
        $time = date('Y-m-d H:i:s');
        $db = new_db_connection(array( // Datum der nächsten Änderung durch Ablauf von Freigabefenstern bestimmen.
            'fields'    => '*',
            'table'     => $pageTable,
            'where'     => 'release_from>:time',
            'bind'      => array('time' => $time),
            'order'     => 'release_from asc',
            'limit'     => '1'
        ));
        if ($db->nextRecord())
        {
            if ($db->Record['release_from']<$cache_expire)
            {
                $cache_expire = $db->Record['release_from'];
            }
        }
        $db->select(array(
            'fields'    => '*',
            'table'     => $pageTable,
            'where'     => 'release_until>:time',
            'bind'      => array('time' => $time),
            'order'     => 'release_until asc',
            'limit'     => '1'
        ));
        if ($db->nextRecord())
        {
            if ($db->Record['release_until']<$cache_expire)
            {
                $cache_expire = $db->Record['release_until'];
            }
        }
        $d = preg_split('/[-, ,:]/', $cache_expire);
        $this->_cache->reset();
 
        $this->_cache->setExpire(mktime($d[3], $d[4], $d[5], $d[1], $d[2], $d[0]));
        $this->setTime(); // Der Zeitstempel für die Freigabeabfrage muss neu gesetzt werden.
 
        // types.cache und classes.cache löschen
        Ego_System::clearTypeCache($this->name);
 
        // Allgemeine Cache löschen (nicht für APCu, da hier die allgemeine Cache die selbe ist wie die Site Cache)
        if ($GLOBALS['egotec_conf']['site_cache_type'] != 'apcu') {
            $cache = Ego_System::getCache();
            $cache->reset();
        }
        Ego_System::clearNginxCache();
    }
 
    public function getGlobalConfig($type) {
        if ($this->global !== null && !empty($this->global[$type])) {
            return $this->global[$type];
        }
        return null;
    }
 
    private function loadGlobalConfig($types = ['site', 'admin']) {
        if ($this->global === null) {
            if (Ego_System::file_exists($file = $GLOBALS['egotec_conf']['var_dir'] . 'conf/global.json')) {
                $this->global = json_decode(Ego_System::file_get_contents($file), true);
            } else {
                $this->global = [];
            }
        }
 
        if (!empty($this->global)) {
            $set_value = function($meta, $type, $key) {
                if (!$this->useGlobalConfig($meta)) {
                    return;
                }
 
                if (isset($meta['value'])) {
                    Ego_System::setAssocValue($this->conf[$type], $key, $meta['value']);
                } elseif (isset($meta['env'])) {
                    Ego_System::setAssocValue($this->conf[$type], $key, $_ENV[$meta['env']]
                        ?? $_SERVER[$meta['env']]
                        ?? (getenv($meta['env'], true) ?: getenv($meta['env']))
                    );
                }
            };
 
            foreach ($types as $type) {
                if (is_array($this->global[$type])) {
                    foreach ($this->global[$type] as $key => $meta) {
                        if (is_array($meta['values'])) {
                            foreach ($meta['values'] as $value) {
                                $set_value($value, $type, $key);
                            }
                        } else {
                            $set_value($meta, $type, $key);
                        }
                    }
                }
            }
        }
    }
 
    private function setGlobalConfig($type) {
        if (!empty($this->global) && is_array($this->global[$type])) {
            foreach ($this->global[$type] as $key => $meta) {
                if (
                    Ego_System::getAssocValue($this->{$type}, $key) !== null
                    && $this->isGlobalConfig($type, $key)
                ) {
                    Ego_System::setAssocValue($this->{$type}, $key, null);
                }
            }
        }
    }
 
    private function isGlobalConfig($type, $search_key) {
        if (!empty($this->global) && is_array($this->global[$type])) {
            foreach ($this->global[$type] as $key => $meta) {
                if ($search_key == $key) {
                    if ($this->useGlobalConfig($meta)) {
                        return true;
                    }
                    break;
                }
            }
        }
        return false;
    }
 
    public function useGlobalConfig($meta) {
        if (is_array($meta['values'])) {
            foreach ($meta['values'] as $value) {
                if ($this->useGlobalConfig($value)) {
                    return true;
                }
            }
            return false;
        } else {
            if (is_array($meta['include'])) {
                foreach ($meta['include'] as $value) {
                    if (strpos($value, 'type:') === 0) {
                        if ($this->site['type'] == substr($value, 5)) {
                            return true;
                        }
                    } elseif ($this->name == $value) {
                        return true;
                    }
                }
                return false;
            } elseif (is_array($meta['exclude'])) {
                foreach ($meta['exclude'] as $value) {
                    if (strpos($value, 'type:') === 0) {
                        if ($this->site['type'] == substr($value, 5)) {
                            return false;
                        }
                    } elseif ($this->name == $value) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
 
    function save($site) {
        require_once 'base/Ego_System.php';
 
        // Sprachen müssen migriert werden, wenn die Standardsprache sich ändert, oder eine Sprache gelöscht wird
        $migrateLanguages = ($this->site['default_language'] !== $site['default_language']) || ($this->site['languages'] !== $site['languages']);
 
        $this->site = array_merge($this->site, $site);
 
        // Globale Konfigurationen werden nicht gespeichert
        $this->setGlobalConfig('site');
 
        if (isset($site['icon'])) {
            $this->site['icon'] = $site['icon'];
        }
 
        // Diese Keys gibt es nicht mehr und sind mittlerweile unterteilt in Sprachen
        unset(
            $this->site['title'],
            $this->site['robots'],
            $this->site['keywords'],
            $this->site['description'],
            $this->_languages
        );
 
        $this->site = Ego_System::cleanTypes($this->site);
        Ego_System::write_ini_file($GLOBALS['egotec_conf']['site_dir'].$this->name.'/conf.ini', $this->site);
 
        if ($migrateLanguages) {
            Ego_Queue::add([$this, 'migrateLanguages']);
        }
 
        // Globale Konfigurationen wieder laden
        $this->loadGlobalConfig(['site']);
 
        return false;
    }
 
    function save_admin($admin=array())
    {
        require_once('base/Ego_System.php');
        $original_admin = $this->admin;
        $this->admin = array_merge($this->admin, $admin);
        $reload_sitemap = false;
 
        // Globale Konfigurationen werden nicht gespeichert
        $this->setGlobalConfig('admin');
 
        $enabled_types = array();
        if(is_array($this->admin['enabled_types']))
        {
            foreach ($this->admin['enabled_types'] as $key => $value)
            {
                if ($value == '1')
                {
                    $enabled_types[$key] = $value;
                }
            }
        }
        $this->admin['enabled_types'] = $enabled_types;
 
        // Schlagwortregister anlegen
        if ($this->admin['keyword_register_own_site']) {
            if (!isset($this->admin['keywords']['site'])) {
                $this->admin['keywords']['site'] = $this->name;
            }
            $reset = $this->admin['keywords']['site'] != $original_admin['keywords']['site'];
            if ($this->name !== $this->admin['keywords']['site']) {
                $origin_site = new Site($this->admin['keywords']['site']);
                $this->createKeywordRegister($origin_site, $reset);
            } else {
                $this->createKeywordRegister(null, $reset);
            }
 
            // Schlagwortregister mit DeepL übersetzen
            if (Ego_System::checkLicence($GLOBALS['egotec_conf']['lib_dir'] . 'translate')) {
                $keyword_register_page = $this->getPages([
                    'where' => "type='_keywords/list'"
                ], [
                    'auth_or' => '1=1'
                ])->nextPage();
 
                if ($keyword_register_page) {
                    $language_link = [];
                    foreach ($this->getLanguages() as $lang) {
                        $language_link[$lang] = $lang == $this->site['default_language']
                            ? 1
                            : ($this->admin['deepl_keywords'] ? 2 : 0);
                    }
                    if (
                        serialize($keyword_register_page->extra['language_link'] ?? []) != serialize($language_link)
                        || $keyword_register_page->extra['language_standard'] != $this->site['default_language']
                    ) {
                        $keyword_register_page->extra['language_link'] = $language_link;
                        $keyword_register_page->extra['language_standard'] = $this->site['default_language'];
                        $keyword_register_page->update();
                    }
 
                    foreach ($keyword_register_page->getDescendants([
                            'where' => "type = '_keywords/entry'"
                        ], [
                        'auth_or' => '1=1'
                    ]) as $keyword) {
                        if (
                            serialize($keyword->extra['language_link'] ?? []) != serialize($language_link)
                            || $keyword->extra['language_standard'] != $this->site['default_language']
                        ) {
                            $keyword->extra['language_link'] = $language_link;
                            $keyword->extra['language_standard'] = $this->site['default_language'];
                            $keyword->update();
                        }
                    }
                }
            }
        } elseif ($original_admin['keyword_register_own_site'] && !$this->admin['keyword_register_own_site']) {
            // wenn Neues Schlagwortregistermodul nicht mehr verwendet wird, dann Schlagwortregister komplett löschen
            $this->createKeywordRegister(null, true, true);
        }
 
        // Seite mit Seitentyp "extern/link" anlegen, falls noch nicht vorhanden
        if ($this->admin['smarty']['external_links']) {
            if ($enabled_types['extern/link']) {
                $extern_link = $this->getPages([
                    'where' => "type = 'extern/link'"
                ], [
                    'auth_or' => '1=1',
                    'inactive' => true,
                    'only_active' => false
                ])->nextPage();
                if (!$extern_link) {
                    $field = array(
                        'name' => $GLOBALS['auth']->translate('Externe Links'),
                        'title' => $GLOBALS['auth']->translate('Externe Links'),
                        'type' => 'extern/link'
                    );
                    $this->getRoot()->newChild($field);
                    $reload_sitemap = true;
                }
            }
        }
 
        // One-Way-Sync: die Datei "ignore_ids" automatisch löschen, wenn diese nicht mehr benötigt wird
        $clusters = Ego_System::getCluster($this);
        $oneway = false;
        if (!empty($clusters)) {
            foreach ($clusters as $cluster) {
                if ($cluster['oneway']) {
                    $oneway = true;
                    break;
                }
            }
        }
        if (!$oneway) {
            foreach ($this->getLanguages() as $lang) {
                $ignore_file = $GLOBALS['egotec_conf']['log_dir'] . $this->name . '_' . $lang . '/ignore_ids';
                if (Ego_System::file_exists($ignore_file)) {
                    @unlink($ignore_file);
                }
            }
        }
 
        $this->admin = Ego_System::cleanTypes($this->admin);
        Ego_System::write_ini_file($GLOBALS['egotec_conf']['site_dir'].$this->name.DIRECTORY_SEPARATOR.'admin'.DIRECTORY_SEPARATOR.'conf.ini', $this->admin);
        Ego_System::clearTypeCache($this->name);
 
        // Globale Konfigurationen wieder laden
        $this->loadGlobalConfig(['admin']);
 
        return $reload_sitemap;
    }
 
    public function migrateLanguages() {
        $params = [
            'inactive' => true,
            'only_active' => false,
            'deleted' => 1,
            'deleted_or' => '1=1',
            'auth_or' => '1=1',
            'no_cache' => true,
        ];
        $pages = $this->getPages([], $params);
 
        foreach ($pages as $page) {
            $currentLanguages = explode(',', $this->site['languages']);
 
            foreach ($currentLanguages as $currentLanguage) {
                $hasChanges = false;
                if ($languagePage = $page->getLanguagePage($currentLanguage, $params)) {
                    if (!in_array($languagePage->extra['language_standard'] ?: '', $currentLanguages)) {
                        $languagePage->extra['language_standard'] = $this->site['default_language'];
 
                        $hasChanges = true;
                    }
 
                    $languagesToDelete = [];
                    $languageLink = !empty($languagePage->extra['language_link']) ? $languagePage->extra['language_link'] : [];
 
                    foreach (array_keys($languageLink) as $lang) {
                        if (!in_array($lang, explode(',', $this->site['languages']))) {
                            $languagesToDelete[] = $lang;
 
                            $hasChanges = true;
                        }
                    }
 
                    foreach ($languagesToDelete as $languageToDelete) {
                        unset($languagePage->extra['language_link'][$languageToDelete]);
                    }
 
                    if ($hasChanges) {
                        $languagePage->update([], true, true);
                    }
                }
            }
        }
    }
 
    private function createKeywordRegister($origin_site = null, $reset = false, $delete = false) {
        $root_page = $this->getRoot();
 
        // Überprüfen ob es bereits ein Schlagwortregister existiert
        $keyword_register_page = $this->getPages([
            'where' => "type='_keywords/list'"
        ], [
            'auth_or' => '1=1'
        ])->nextPage();
 
        if ($keyword_register_page) {
            if ($reset) {
                // Wenn das Schlagwortregister gewechselt wird, muss es neu angelegt werden
                $keyword_register_page->delete(false, false, true, [
                    'where' => "type = '_keywords/entry'"
                ]);
                $this->clearTrashcan([
                    'where' => "type = '_keywords/list' OR type = '_keywords/entry'"
                ]);
            } else {
                // Wenn ein Schlagwortregister existiert, dann nicht machen.
                return;
            }
        }
 
        if ($origin_site && !$delete) {
            // Schlagwortregisterstartseite klonen.
            $origin_page = $origin_site->getPages([
                'where' => "type='_keywords/list'"
            ], [
                'auth_or' => '1=1'
            ])->nextPage();
 
            if (!$origin_page) { // Wenn beim Originalmandant kein Schlagwortregister existiert,
                $keyword_register_field = [
                    'name' => "Schlagwortregister",
                    'title' => "Schlagwortregister",
                    'type' => "_keywords/list",
                    'inactive' => 0,
                    'nav_hide' => 1+4+8 // Aus Navigation, Sitemap und Suche ausschließen.
                ];
 
                $origin_page = $origin_site->getRoot()->newChild($keyword_register_field); // dann dieses erstellen.
            } elseif ($origin_page->isClone()) { // Wenn der ausgewählte Mandant ebenfalls Klone nutzt,
                $origin_page = $origin_page->getCloneOriginal(); // so wird das Original geklont.
            }
            $clone_page = $root_page->createClone($origin_page);
 
            $keyword_recursive = function($origin_page, $clone_page) use (&$keyword_recursive) {
                $origin_children = $origin_page->getChildren([
                    'where' => "type='_keywords/entry'"
                ], [
                    'auth_or' => '1=1'
                ]);
 
                foreach ($origin_children as $origin_child) {
                    // Wenn das Schlagwort ein Klon ist, dann Klon von Original erstellen
                    if ($origin_child->isClone()) {
                        $clone_child = $clone_page->createClone($origin_child->getCloneOriginal());
                    } else {
                        $clone_child = $clone_page->createClone($origin_child);
                    }
                    $keyword_recursive($origin_child, $clone_child);
                }
            };
            $keyword_recursive($origin_page, $clone_page);
        } elseif (!$delete) {
            $keyword_register_field = [
                'name' => "Schlagwortregister",
                'title' => "Schlagwortregister",
                'type' => "_keywords/list",
                'inactive' => 0,
                'nav_hide' => 1+4+8 // Aus Navigation, Sitemap und Suche ausschließen.
            ];
            $root_page->newChild($keyword_register_field);
        }
    }
 
    private function _sortTypes(&$arr) {
        $names = [];
        foreach ($arr as $value) {
            $names[] = str_replace(
                ['ä', 'ö', 'ü', 'ß', '-', ' '],
                ['ae', 'oe', 'ue', 'ss', '_', '_'],
                mb_strtolower($value['fullname'])
            );
        }
 
        array_multisort($names, SORT_ASC, SORT_NATURAL, $arr);
    }
 
    private function _getTypesOfDirectory($root_dir, $site_name, $type='', $fullname='', $depth=-1, $site_type='')
    {
        $original_root_dir = $root_dir;
        if (
            file_exists($type_file = rtrim($root_dir.($type?$type.'/':''), '/').'/type.ini')
            || (
                $root_dir != $GLOBALS['egotec_conf']['site_dir'].'_global/'
                && file_exists($type_file = rtrim($GLOBALS['egotec_conf']['site_dir'].'_global/'.($type?$type.'/':''), '/').'/type.ini')
                && ($root_dir = $GLOBALS['egotec_conf']['site_dir'].'_global/')
            )
            || (
                $root_dir != $GLOBALS['egotec_conf']['lib_dir'].'type/site/'
                && file_exists($type_file = rtrim($GLOBALS['egotec_conf']['lib_dir'].'type/site/'.($type?$type.'/':''), '/').'/type.ini')
                && ($root_dir = $GLOBALS['egotec_conf']['lib_dir'].'type/site/')
            )
        ) {
            $entry = parse_ini_file($type_file, true);
 
            $fullname = ($fullname?$fullname.'/':'').$entry['title'];
            $global = false;
            if (
                $root_dir == $GLOBALS['egotec_conf']['lib_dir'].'type/site/'
                || $root_dir == $GLOBALS['egotec_conf']['site_dir'].'_global/'
            ) {
                $global = true;
            }
 
            $system = false;
            switch ($type) {
                case '_keywords':
                case '_keywords/abbreviations':
                case '_keywords/entry':
                case '_keywords/list':
                    if ($this->admin['keyword_register_own_site']) {
                        $system = true;
                    } else {
                        $entry['hidden'] = true;
                    }
            }
 
            $inherit = false;
            $parent_type = explode('/', $type)[0];
            if (
                $root_dir == $GLOBALS['egotec_conf']['lib_dir'].'type/site/'
                && !$this->admin['enabled_types'][$type]
                && (
                    is_dir($GLOBALS['egotec_conf']['site_dir'] . "{$this->name}/$parent_type")
                    || ($this->theme && is_dir($GLOBALS['egotec_conf']['pub_dir'] . "theme/{$this->theme}/site/$parent_type"))
                )
            ) {
                $inherit = true;
            }
 
            $types = array(
                'depth'     => $depth,
                'type'      => $type,
                'name'      => $entry['title'],
                'fullname'  => $fullname,
                'active'    => !$entry['inactive'],
                'hidden'    => (bool) $entry['hidden'],
                'global'    => $global,
                'system'    => $system,
                'inherit'   => $inherit,
                'blacklist' => $entry['blacklist'],
                'whitelist' => $entry['whitelist']
            );
 
            // Blacklist - Wenn der Seitentyp vom Mandanten ausgeschlossen ist.
            $excluded_sites = explode(',', $types['blacklist']);
 
            if ($types['whitelist']) {
                // Whitelist - Wenn der Seitentyp nur auf bestimmten Mandanten verfügbar ist.
                $included_sites = explode(',', $types['whitelist']);
            }
            // Wenn sich der Seitentyp auf der Blacklist befindet, nicht anzeigen.
            if (is_array($excluded_sites) && in_array($site_name, $excluded_sites)) {
                return [];
            }
 
            // Wenn eine Whitelist vorhanden ist und der Seitentyp nicht auf dieser ist, nicht anzeigen.
            if (is_array($included_sites) && !empty($included_sites) && !in_array($site_name, $included_sites) ) {
                return [];
            }
 
            // Der Seitentyp wird nicht angezeigt
            if ($types['hidden']) {
                return [];
            }
 
            foreach (array("icon","jquery") as $k)
            {
                if ($entry[$k])
                {
                    $types[$k] = $entry[$k];
                }
            }
 
        }
 
        $get_types = function($this_dir) use ($site_name, $type, $fullname, $depth, $site_type, &$types) {
            $dir = dir($this_dir.($type?$type.'/':''));
            while ($file = $dir->read())
            {
                if ($file[0]!='.' && is_dir($dir->path.$file) && ($file!='multimedia' || $site_type=='media'))
                {
                    $type_array = $this->_getTypesOfDirectory($this_dir, $site_name, ($type?$type.'/':'').$file, $fullname, $depth+1, $site_type);
                    if ($type_array)
                    {
                        $types['children'][$type_array['type']] = $type_array;
                    }
                }
            }
        };
 
        if ($root_dir != $original_root_dir && is_dir($root_dir.($type?$type.'/':'')))
        {
            // Fallback Seitentypen aufnehmen
            $get_types($root_dir);
        }
        if (is_dir($original_root_dir.($type?$type.'/':'')))
        {
            $get_types($original_root_dir);
        }
 
        if ($types['children'])
        {
            $this->_sortTypes($types['children']);
        }
 
        return $types;
    }
 
    private static function _getFlatTypes($tree)
    {
        $types_array = array();
        if(is_array($tree))
        {
            foreach ($tree as $item)
            {
                $types_array[] = $item;
                if ($item['children'])
                {
                    $types_array = array_merge($types_array, Site::_getFlatTypes($item['children']));
                }
            }
        }
        return $types_array;
    }
 
    function getTypes($flat=true,$params=array())
    {
        $get = function() use ($flat, $params) {
            $cache_file = $GLOBALS['egotec_conf']['cache_dir'].$this->name.'/types'.($flat ? 'Flat' : '').md5(serialize(array($params)));
            if (
                Ego_System::file_exists($cache_file)
                && ($types = @unserialize(Ego_System::file_get_contents($cache_file)))
            ) {
                return $types;
            }
 
            if ($params['only_system'])
            {//Systemseitentypen die NICHT durch Mandantenspezifische Seitentypen überschrieben werden
                $types = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].$this->name.'/', $this->name);
                $types1 = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['pub_dir'].'type/site/', $this->name);
                $types2 = $this->theme ? $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['pub_dir']."theme/{$this->theme}/site/", $this->name) : null;
                $types3 = $this->globalAllowed() ? $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].'_global/', $this->name) : null;
                $types4 = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['lib_dir'].'type/site/', $this->name, '', '', -1, $this->site['type']);
 
                if (is_array($types)) {
                    $result_types['children'] = array_diff_key($types4['children'],$types['children']);
                } else {
                    $result_types = $types4;
                }
                if (is_array($types3)) {
                    $result_types['children'] = array_diff_key($result_types['children'],$types3['children']);
                }
                if (is_array($types2)) {
                    $result_types['children'] = array_diff_key($result_types['children'], $types2['children']);
                }
                if (is_array($types1)) {
                    $result_types['children'] = array_merge($result_types['children'],$types1['children']);
                }
                $this->_types = $result_types['children']?$result_types['children']:array();
                if ($params['include_theme']) {
                    $theme_types = $types2['children']?$types2['children']:array();
                    $this->_types = array_merge($this->_types, $theme_types);
                }
                if ($params['include_global']) {
                    $global_types = $types3['children']?$types3['children']:array();
                    $this->_types = array_merge($this->_types, $global_types);
                }
            } elseif ($params['only_global'])
            {
                if ($this->globalAllowed()) {
                    $types = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].'_global/', $this->name);
                    $this->_types = $types['children']?$types['children']:array();
                } else {
                    $this->_types = array();
                }
            } elseif ($params['only_site'])
            {
                $types = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].$this->name.'/', $this->name);
                $this->_types = $types['children']?$types['children']:array();
            } elseif ($params['only_theme'])
            {
                $types = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->theme.'/site/', $this->name);
                $this->_types = $types['children']?$types['children']:array();
            } else
            {
                if (!$this->_types)
                {
                    $types_filename=$GLOBALS['egotec_conf']['cache_dir'].$this->name.'/types.cache';
                    if (Ego_System::file_exists($types_filename))
                    {
                        $this->_types = @unserialize(Ego_System::file_get_contents($types_filename));
                    } else
                    {
                        $types = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].$this->name.'/', $this->name);
                        $types1 = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['pub_dir'].'type/site/', $this->name);
                        $types2 = $this->theme ? $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['pub_dir']."theme/{$this->theme}/site/", $this->name) : null;
                        $types3 = $this->globalAllowed() ? $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['site_dir'].'_global/', $this->name) : null;
                        $types4 = $this->_getTypesOfDirectory($GLOBALS['egotec_conf']['lib_dir'].'type/site/', $this->name, '', '', -1, $this->site['type']);
 
                        $this->_types = array_merge(
                            $types4['children']?$types4['children']:array(),
                            $types3['children']?$types3['children']:array(),
                            $types2['children']?$types2['children']:array(),
                            $types1['children']?$types1['children']:array(),
                            $types['children']?$types['children']:array()
                        );
                        Ego_System::file_put_contents($types_filename, serialize($this->_types));
                    }
                }
            }
 
            if ($flat)
            {
                $md5 = md5(serialize($params));
                if (!$this->_typesFlat[$md5])
                {
                    $this->_typesFlat[$md5] = Site::_getFlatTypes($this->_types);
                }
                $this->_sortTypes($this->_typesFlat[$md5]);
                Ego_System::file_put_contents($cache_file, serialize($this->_typesFlat[$md5]));
                return $this->_typesFlat[$md5];
            } else
            {
                $this->_sortTypes($this->_types);
                Ego_System::file_put_contents($cache_file, serialize($this->_types));
                return $this->_types;
            }
        };
 
        $types = $get();
 
        // Kundenspezifischen Filter anwenden
        if (Ego_System::file_exists($system_path = $GLOBALS['egotec_conf']['var_dir'] . 'lib/site_get_types.php')) {
            require_once $system_path;
            if (function_exists('site_get_types')) {
                $types = site_get_types($this, $types, $flat, $params);
            }
        }
 
        return $types;
    }
 
    function getKeywords($query = []) {
        $keywords = [];
 
        $recursive = function($parent, $depth = 0) use (&$recursive, &$keywords, $query) {
            $query_where = "type = '_keywords/entry'" . ($query['where'] ? " AND ({$query['where']})" : '');
            unset($query['where']);
            $children = $parent->getChildren(array_merge(['where' => $query_where], $query), ['sitemap' => false]);
            foreach ($children as $child) {
                $child->field['depth'] = $depth;
                $keywords[] = $child;
                $recursive($child, $depth + 1);
            }
        };
 
        $keyword_lists = $this->getPages(['where' => 'type = "_keywords/list"'], ['sitemap' => false]);
        foreach ($keyword_lists as $keyword_list) {
            $recursive($keyword_list);
        }
 
        return $keywords;
    }
 
    function getTypeInfo($name) {
        if (!empty($this->_types)) {
            $parts = explode('/', $name);
            $type = $this->_types[$parts[0]];
            $child = '';
            foreach ($parts as $index => $part) {
                if ($type['type'] == $name) {
                    return $type;
                } else {
                    if (empty($child)) {
                        $child = $part;
                    } else {
                        $child .= '/'.$part;
                    }
                    if (!empty($type['children']) && !empty($type['children'][$child])) {
                        $type = $type['children'][$child];
                        if ($type['type'] == $name) {
                            return $type;
                        }
                    }
                }
            }
        } else {
            $types = $this->getTypes();
            foreach ($types as $type) {
                if ($type['type'] == $name) {
                    return $type;
                }
            }
        }
        return array();
    }
 
    function getTypeFiles($type)
    {
        $files = array();
        $dirs_to_read = array(
            'site &raquo; ' => array(
                $GLOBALS['egotec_conf']['lib_dir'].'type/site/'.$type,
                $this->globalAllowed() ? $GLOBALS['egotec_conf']['site_dir'].'_global/'.$type : '',
                $GLOBALS['egotec_conf']['site_dir'].$this->name.'/'.$type,
            ),
            'site/admin &raquo; ' => array(
                $GLOBALS['egotec_conf']['lib_dir'].'type/site/'.$type.'/admin',
                $this->globalAllowed() ? $GLOBALS['egotec_conf']['site_dir'].'_global/'.$type.'/admin' : '',
                $GLOBALS['egotec_conf']['site_dir'].$this->name.'/'.$type.'/admin',
            ),
            'skin &raquo; ' => array(
                $GLOBALS['egotec_conf']['bin_dir'].'type/skin/'.$type,
                $GLOBALS['egotec_conf']['lib_dir'].'type/skin/'.$type,
                $this->globalAllowed() ? $GLOBALS['egotec_conf']['skin_dir'].'_global/'.$type : '',
                $GLOBALS['egotec_conf']['skin_dir'].$this->skin.'/'.$type
            )
        );
        if (!empty($this->theme)) {
            $dirs_to_read[$this->theme.' &raquo; '] = array(
                $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->theme.'/site/'.$type,
                $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->theme.'/skin/'.$type,
            );
            $dirs_to_read[$this->theme.'/admin &raquo; '] = array(
                $GLOBALS['egotec_conf']['pub_dir'].'theme/'.$this->theme.'/site/'.$type.'/admin'
            );
        }
 
        foreach ($dirs_to_read as $key => $dirs)
        {
            foreach ($dirs as $d)
            {
                if (!$d) {
                    continue;
                }
                $dir = @dir($d);
                while ($dir && false !== ($f = $dir->read()))
                {
                    if ($f[0]=='.' || is_dir($dir->path.'/'.$f)) continue;
 
                    $files[$key.'/'.$f] = $dir->path.'/'.$f;
                }
            }
        }
 
        return $files;
    }
 
    function getSitemapRootIdArray($param = array(), $recalc = false, $user = true, $query = array())
    {
        $key = md5($this->pageTable.json_encode($this->_param));
 
        // Aus dem User Objekt holen
        if (
            !$recalc
            && $user
            && is_array($GLOBALS['auth']->user->extra['rootIdArray'])
            && is_array($GLOBALS['auth']->user->extra['rootIdArray'][$key])
        ) {
            return $GLOBALS['auth']->user->extra['rootIdArray'][$key];
        }
 
        $where = $query['where'];
        unset($query['where']);
        $query = array_merge(array(
            'fields' => $this->pageTable.'.id, '. $this->pageTable.'_children.page_id, parent.type',
            'inner' => array(
                $this->pageTable.'_children ON '.$this->pageTable.'_children.child='.$this->pageTable.'.id',
                $this->pageTable.' AS parent ON '.$this->pageTable.'_children.page_id=parent.id'
            ),
            'distinct' => true
        ), $query);
        $query['where'] = "parent.type != '_keywords/entry'";
        if ($where) {
            $query['where'] .= " AND ($where)";
        }
        $all_parents = $this->getPages($query, $param);
 
        $id_string = '';
        $parent_string = '';
        foreach ($all_parents as $page)
        {
            if ($page->field['page_id']) {
                $parent_string = $parent_string.','.$page->field['page_id'];
            }
            $id_string = $id_string.','.$page->field['id'];
        }
        $parent_string = trim($parent_string,',');
        $id_string = trim($id_string,',');
 
        $parents = array();
        $all_ids = array();
        $parents = empty($parent_string) ? array() : explode(',', $parent_string);
        $all_ids = empty($id_string) ? array() : explode(',', $id_string);
        $parents = array_unique($parents);
        $all_ids = array_unique($all_ids);
 
        if ($param['deleted'] == 1)
        { // Die Eltern aller gelöschten Seiten zurückgeben.
            $ids = $parents;
        } elseif (empty($parents))
        { // es gibt keine Eltern
            $ids = array();
        } else {
            $with_permission = $all_ids; // Alle Eltern bestimmen, auf die der Benutzer eine Berechtigung besitzt.
            $ids = array(); // Alle Vorfahren zu den Eltern bestimmen, für die der Benutzer keine Berechtigung besitzt.
            $page = $this->getRoot(array('auth_or' => '1=1', 'deleted_or' => '1=1'));
 
            foreach ($parents as $id)
            {
                if (!in_array($id, $with_permission))
                {
                    $ids = array_merge($ids,$page->_getAncestorsIds(
                        $this->getPage($id, array('auth_or' => '1=1')),
                        array('limit' => 1, 'order' => 'id'),
                        array('auth_or' => '1=1', 'deleted' => -1)
                    ));
                    $ids[] = $id;
                }
            }
        }
 
        if ($param['all_ids']) {
            $ids = array_merge($ids, $all_ids);
        }
 
        $ids = array_unique($ids);
 
        // Im User Objekt speichern
        if (!isset($param['deleted']) && $user) {
            if (!is_array($GLOBALS['auth']->user->extra['rootIdArray'])) {
                $GLOBALS['auth']->user->extra['rootIdArray'] = array();
            }
            $GLOBALS['auth']->user->extra['rootIdArray'][$key] = $ids;
            $GLOBALS['auth']->user->update();
        }
 
        return $ids;
    }
 
    function hasRight($right, $flag=false, $user_id = false, $rights = array())
    {
        $rights = !empty($rights) ? $rights : $this->admin['right'];
        if ($right == "desktop")
        {
            $flag = true;
        }
        $i = 0;
        do
        {
            $group = $rights[$right.'_group_'.$i];
            if ($group=='')
            {
                break;
            }
            $role = $rights[$right.'_role_'.$i];
            if ($GLOBALS['auth']->hasPermission($group, $role, $flag, $user_id))
            {
                return true;
            }
            $i++;
        } while ($group!='');
        return $i==0;
    }
 
    function hasPermission($right)
    {
        $rights = $this->admin['right'];
 
        if (is_array($rights))
        {
            foreach ($rights as $r => $value)
            {
                if (preg_match('/^'.$right.'_group_(\d+)/i', $r, $g))
                {
                    $group = $g[1];
 
                    if (isset($rights[$right.'_role_'.$group]) && !$this->isPermission($value, $rights[$right.'_role_'.$group]))
                    {
                        return false;
                    }
                }
            }
        }
 
        return true;
    }
 
    function isPermission($group, $role)
    {
        if (empty($group) && empty($role))
        {
            return true;
        }
 
        $db = new_db_connection(
            array(
                'fields' => 'group_id',
                'table' => 'egotec_group',
                'where' => 'group_id =:group',
                'bind' => array(
                    'group' => $group
                )
            )
        );
        if($db->nextRecord())
        {
            $db = new_db_connection(
                array(
                    'fields' => 'role_id',
                    'table' => 'egotec_role',
                    'where' => 'role_id =:role',
                    'bind' => array(
                        'role' => $role
                    )
                )
            );
 
            return $db->nextRecord();
        }else
        {
            return false;
        }
    }
 
    public function checkCondition($condition) {
        $valid = false;
 
        $sub_queries = preg_split('/\s+(and|or)\s+/si', $condition);
        foreach ($sub_queries as $sub_query) {
            if (preg_match('/(!?(site|admin|conf|egotec_conf)\.([^ !=<>]+))(\s*(like|>=|<=|!=|=|>|<)\s*(.*?))?$/si', trim($sub_query, '() '), $matches)) {
                $param = $matches[1];
                $type = $matches[2];
                $operator = mb_strtolower($matches[5]);
                $check = trim($matches[6], '\'"');
                $field = $matches[3];
 
                // Feld darf nicht gesetzt sein
                $exclude = $param[0] == '!';
 
                // Aktueller Wert
                if ($type == 'egotec_conf') {
                    $value = Ego_System::getAssocValue($GLOBALS['egotec_conf'], $field);
                } else {
                    $value = Ego_System::getAssocValue($this->{$type}, $field);
                }
 
                if ($exclude) {
                    $valid = !isset($value);
                } else {
                    switch ($operator) {
                        case 'like':
                            $valid = mb_strpos($check, $value) !== false;
                            break;
                        case '>=':
                            $valid = $value >= $check;
                            break;
                        case '<=':
                            $valid = $value <= $check;
                            break;
                        case '!=':
                            $valid = $value != $check;
                            break;
                        case '=':
                            $valid = $value == $check;
                            break;
                        case '>':
                            $valid = $value > $check;
                            break;
                        case '<':
                            $valid = $value < $check;
                            break;
                        default:
                            $valid = isset($value);
                    }
                }
            }
        }
 
        return $valid;
    }
 
    function checkRight($right, $flag=false)
    {
        if ($this->hasRight($right, $flag))
        {
            return true;
        } else {
            throw new Auth_Exception(Auth_Exception::PERMISSION_DENIED_TEXT, Auth_Exception::PERMISSION_DENIED);
        }
    }
 
    public function getRights($right) {
        $rights = array();
        $i = 0;
        do {
            $group = $this->admin['right'][$right.'_group_'.$i];
            if ($group == '') {
                break;
            }
            $role = $this->admin['right'][$right.'_role_'.$i];
            $rights[] = array('group' => $group, 'role' => $role);
            $i++;
        } while ($group != '');
        return $rights;
    }
 
    public function setRight($right, $rights) {
        // Zunächst alle bisherigen Einträge löschen.
        $i = 0;
        do {
            $group = $this->admin['right'][$right.'_group_'.$i];
            if ($group == '') {
                break;
            }
            unset($this->admin['right'][$right.'_group_'.$i]);
            unset($this->admin['right'][$right.'_role_'.$i]);
            $i++;
        } while ($group != '');
 
        // Jetzt die Rechte setzen.
        $i = 0;
        foreach ($rights as $one_right) {
            $this->admin['right'][$right.'_group_'.$i] = $one_right['group'];
            $this->admin['right'][$right.'_role_'.$i] = $one_right['role'];
        }
    }
 
    function destroyIDs($ids)
    {
        $languages = $this->getLanguages();
        $name = $this->name;
        foreach($languages as $language)
        {
            foreach($ids as $id)
            {
                $_dbErase = new_db_connection();
                $_dbErase->delete(array('from' => $name.'_'.$language, 'where' => 'id = \''.$id.'\''));
                $_dbErase->delete(array('from' => $name.'_'.$language.'_fulltext', 'where' => 'id = \''.$id.'\''));
                $_dbErase->delete(array('from' => $name.'_'.$language.'_rights', 'where' => 'page_id = \''.$id.'\''));
                $_dbErase->delete(array('from' => $name.'_'.$language.'_users', 'where' => 'page_id = \''.$id.'\''));
                $_dbErase->delete(array('from' => $name.'_'.$language.'_v', 'where' => 'id = \''.$id.'\''));
            }
        }
    }
 
    function hasRightsOnId($id, $rights, $user_id = false, $cache = true)
    {
        if (!$user_id && $GLOBALS['auth']->hasSuperuserPermission()) {
            return true;
        }
 
        $cache_key = 'rights' . md5(serialize([
            $GLOBALS['auth']->isNobody()
                ? null
                : $GLOBALS['auth']->user->field['user_id'],
            $id,
            $rights,
            $user_id
        ]));
        $cache_entry = $this->getCacheEntry($cache_key);
        if (!$cache || $cache_entry === null) {
            $query = array(
                'fields'=> 'id',
                'from'  => $this->pageTable,
                'where' => 'id='.$id
            );
            $db = new_db_connection(
                $GLOBALS['auth']->getPageTableQuery(
                    $this->pageTable,
                    $rights,
                    $query,
                    array(
                        'user_id'   => $user_id
                    )
                )
            );
            $cache_entry = (boolean) $db->nextRecord();
            $this->setCacheEntry($cache_key, $cache_entry);
        }
        return $cache_entry;
    }
 
    public function isMetaUrl($path)
    {
        if (isset($this->_cachedMetaUrls[$path])) {
            return $this->_cachedMetaUrls[$path];
        }
        $db = new_db_connection(array(
            'table' => $this->pageTable,
            'fields' => 'url',
            'where' => 'url = :url',
            'bind' => array(
                'url' => $path
            )
        ));
        return $this->_cachedMetaUrls[$path] = ((bool) $db->nextRecord());
    }
 
    public function isPublicSave() {
        return $this->site['type'] == 'content' && $GLOBALS['egotec_conf']['save_method'] == 'public';
    }
 
    public function __toString()
    {
        return 'Site('.$this->name.'.'.$this->language.')';
    }
 
    public function __clone()
    {
        if ($this->_cache) {
            /* Wenn das Site Objekt geklont wird, muss das Cache Objekt ebenfalls geklont werden,
             * da es ansonsten eine Referenz zum originalen Objekt ist. */
            $this->_cache = clone $this->_cache;
        }
    }
 
    public function enoughDiskSpace()
    {
        $need_space = 2*1024*1024*1024; // 2 GB
        $dir_name = $GLOBALS['egotec_conf']['backup_dir'].'site/'.$this->name;
        if (Ego_System::file_exists($dir_name))
        {
            $times = array();
            $newest = 0;
            $dir = dir($GLOBALS['egotec_conf']['backup_dir'].'site/'.$this->name);
            while (false !== ($f = $dir->read()))
            {
                if (strrpos($f, '.tar.gz')===strlen($f)-7)
                {
                    $time = filemtime($dir_name.'/'.$f);
                    $times[$time] = filesize($dir_name.'/'.$f);
                    $newest = $time > $newest ? $time : $newest;
                }
            }
            $dir->close();
            ksort($times);
            if (sizeof($times)>0)
            {
                $need_space = intval($times[$newest]) *3;
            }
        } else
        {
            if (!Ego_System::file_exists($GLOBALS['egotec_conf']['backup_dir']))
            {
                Ego_System::mkdir($GLOBALS['egotec_conf']['backup_dir']);
            }
            $dir_name = $GLOBALS['egotec_conf']['backup_dir'];
 
            // Backup Verzeichnis existiert nicht, dann anlegen
            if (!Ego_System::file_exists($dir_name))
            {
                Ego_System::mkdir($dir_name);
            }
        }
        if ($need_space < disk_free_space($dir_name))
        {
            return true;
        } else
        {
            return false;
        }
    }
 
    public function getCache()
    {
        return $this->_cache;
    }
 
    public function getCacheExpire()
    {
        $expire = (int) $this->admin['cache_expire_time'];
        if ($expire == 0) {
            $expire = 3600; // Standard: 1 Stunde
        }
        return $expire;
    }
 
    public function getCacheEntry($key)
    {
        if ($_REQUEST['preview']) {
            $key .= 'P';
        }
        if ($_REQUEST['c_date']) {
            $key .= 'C' . md5($_REQUEST['c_date']);
        }
        return $this->_cache->get($key);
    }
 
    public function setCacheEntry($key, $value)
    {
        if ($_REQUEST['preview']) {
            $key .= 'P';
        }
        if ($_REQUEST['c_date']) {
            $key .= 'C' . md5($_REQUEST['c_date']);
        }
        $this->_cache->set($key, $value);
    }
 
    public function getCacheLastChanged()
    {
        return $this->_cache->getLastChanged();
    }
 
    public function getDesklets($rights = false, $trashcan = false) {
        $site = $this;
        $auth = clone $GLOBALS['auth'];
        $smarty = clone $GLOBALS['smarty'];
        $active_cells = $GLOBALS['active_cells'] = explode(',', $GLOBALS['auth']->user->extra[$this->name.'_desktop_cells']);
 
        // Standard Inhalt für leere Desklets
        $desklet_default_content = '<p class="refresh"><a href="javascript:void(0)" onclick="egoDesktop.refresh()">'
            .$GLOBALS['auth']->translate('Laden Sie den Desktop neu, um den Inhalt dieses Desklets anzuzeigen.')
            .'</a></p>';
        $smarty->assign('desklet_default_content', $desklet_default_content);
 
        $desktop_dir = dir($GLOBALS['egotec_conf']['lib_dir'].'desktop/'.($trashcan ? 'trashcan/' : ''));
        while ($desktop_file = $desktop_dir->read()) {
            if (
                is_file($desktop_dir->path.$desktop_file)
                && substr($desktop_file, strlen($desktop_file)-4) == '.php'
                && file_exists($desktop_dir->path.$desktop_file)
            ) {
                require($desktop_dir->path.$desktop_file);
            }
        }
        $desktop_dir->close();
        if (!$trashcan) {
            if ($this->globalAllowed() && file_exists($GLOBALS['egotec_conf']['site_dir'].'_global/admin/desktop/')) {
                $desktop_dir = dir($GLOBALS['egotec_conf']['site_dir'].'_global/admin/desktop/');
                while ($desktop_file = $desktop_dir->read()) {
                    if (
                        is_file($desktop_dir->path.$desktop_file)
                        && substr($desktop_file, strlen($desktop_file)-4) == '.php'
                        && file_exists($desktop_dir->path.$desktop_file)
                    ) {
                        require($desktop_dir->path.$desktop_file);
                    }
                }
                $desktop_dir->close();
            }
            if (file_exists($GLOBALS['egotec_conf']['site_dir'].$this->name.'/admin/desktop/')) {
                $desktop_dir = dir($GLOBALS['egotec_conf']['site_dir'].$this->name.'/admin/desktop/');
                while ($desktop_file = $desktop_dir->read()) {
                    if (
                        is_file($desktop_dir->path.$desktop_file)
                        && substr($desktop_file, strlen($desktop_file)-4) == '.php'
                        && file_exists($desktop_dir->path.$desktop_file)
                    ) {
                        require($desktop_dir->path.$desktop_file);
                    }
                }
                $desktop_dir->close();
            }
            foreach ($this->getTypes() as $type) {
                $desktop_file = $GLOBALS['egotec_conf']['site_dir'].$this->name.'/'.$type['type'].'/admin/desktop.php';
                if ($this->globalAllowed() && !file_exists($desktop_file)) { // Fallback in das _global Verzeichnis.
                    $desktop_file = $GLOBALS['egotec_conf']['site_dir'].'_global/'.$type['type'].'/admin/desktop.php';
                }
                if (!file_exists($desktop_file)) { // Fallback in das lib/type Verzeichnis.
                    $desktop_file = $GLOBALS['egotec_conf']['lib_dir'].'type/site/'.$type['type'].'/admin/desktop.php';
                }
                if (file_exists($desktop_file)) {
                    require($desktop_file);
                }
            }
 
            foreach ($GLOBALS['cells'] as $index => &$cell_item) {
                if (is_array($cell_item)) {
                    foreach ($cell_item as &$cell) {
                        if ($rights && isset($site->admin['desklets'][$cell['id']])) {
                            $rights = explode(';', $site->admin['desklets'][$cell['id']]);
                            if (sizeof($rights) > 0) {
                                $perm = false;
                                foreach ($rights as $right) {
                                    $group_role = explode(',', $right);
                                    if (
                                        empty($group_role[0])
                                        || empty($group_role[1])
                                        ||$GLOBALS['auth']->hasPermission($group_role[0], $group_role[1])
                                    ) {
                                        $perm = true;
                                    }
                                }
                                if (!$perm) {
                                    unset($GLOBALS['cells'][$index]);
                                    break;
                                }
                            }
                        }
                        $cell['visible'] = ($cell['permanent'] || in_array($this->name.'_'.$cell['id'], $active_cells));
                        $cell['permanent'] = !empty($cell['permanent']);
 
                        // Leere Desklets mit einem Standard Inhalt befüllen
                        if (trim($cell['body']) == '') {
                            $cell['body'] = $desklet_default_content;
                        }
                    }
                }
            }
        }
        return $GLOBALS['cells'] = array_values($GLOBALS['cells']);
    }
 
    public function getCRS() {
        $crs = json_decode(Ego_System::file_get_contents($GLOBALS['egotec_conf']['lib_dir'] . 'smarty/plugins/leaflet/crs.json'), true);
        if ($custom_crs = $this->getSiteFile('admin/crs.json')) {
            $crs = array_merge($crs, json_decode(Ego_System::file_get_contents($custom_crs), true));
        }
        return $crs;
    }
 
    public function getUploaderPage($page = null) {
        if ($file = $this->getSiteFile('admin/uploader.php')) {
            require_once($file);
            if (function_exists('getUploaderPage')) {
                if (!$page && $GLOBALS['page']) {
                    $page = $GLOBALS['page'];
                }
                return getUploaderPage($this, $page);
            }
        } elseif ($this->hasMediaSite()) {
            $media_site = $this->getMediaSite();
            $media_site->addParam(array(
                'auth_or' => '1=1'
            ));
            $_users_page = $media_site->getPages(
                array('where' => 'name=\'_users\''),
                array(
                    'auth_or' => '1=1',
                    'inactive' => true,
                    'only_active' => false
                )
            )->nextPage();
            if (!$_users_page)
            {
                $media_root_page = $media_site->getRoot(array('auth_or' => '1=1'));
                if (!$media_root_page) {
                    return null;
                } else {
                    $_users_page = $media_root_page->newChild(array(
                        'name'  => '_users',
                        'title' => '_users',
                        'type'  => 'multimedia/category',
                        'inactive' => 0
                    ));
                }
            }
            $user_page = $_users_page->getChildren(
                array(
                    'where' => 'name=:name',
                    'bind' => array(
                        'name' => $GLOBALS['auth']->user->field['username']
                    )
                ),
                array(
                    'auth_or' => '1=1',
                    'inactive' => true,
                    'only_active' => false
                )
            )->nextPage();
            if (!$user_page && !empty($GLOBALS['auth']->user->field['username']))
            {
                $user_page = $_users_page->newChild(array(
                    'name'  => $GLOBALS['auth']->user->field['username'],
                    'title' => $GLOBALS['auth']->user->field['username'],
                    'type'  => 'multimedia/category',
                    'inactive'  => 0
                ));
                $user_page->setUsersArray(array(
                    'edit'  => array(array('user_id' => $GLOBALS['auth']->getId())),
                    'child' => array(array('user_id' => $GLOBALS['auth']->getId())),
                    'remove'    => array(array('user_id' => $GLOBALS['auth']->getId()))
                ));
 
                // Sicherstellen, dass es mindestens eine Gruppen/Rollen Kombination gibt
                $rights = $user_page->getRightsArray();
                foreach (array('edit', 'child', 'remove') as $perm) {
                    if (
                        empty($rights[$perm])
                        || in_array('*', array($rights[$perm][0]['group_id'], $rights[$perm][0]['role_id']))
                    ) {
                        $rights[$perm] = array(
                            array(
                                'group_id' => $GLOBALS['egotec_conf']['superuser']['group'],
                                'role_id' => $GLOBALS['egotec_conf']['superuser']['role']
                            )
                        );
                    }
                }
                $user_page->setRightsArray($rights);
            }
            return $user_page;
        }
        return null;
    }
 
    public function hasDeleted() {
        $deleted = $this->getPages(array(), array(
            'auth_or' => '1=1',
            'deleted' => 1
        ));
        return (bool) $deleted->nextPage();
    }
 
    public function clearTrashcan($query = array()) {
        $cluster_list = Ego_System::getCluster($this);
        $original_where = '';
        if (empty($query['where'])) {
            $query['where'] = '1=1';
        } else {
            $original_where = $query['where'];
        }
        if (count($cluster_list) > 0) {
            $time = array();
            foreach ($cluster_list as $cluster) {
                $log_filename = $GLOBALS['egotec_conf']['log_dir'].$this->name.'/live.'.$this->name.'_'.$this->language.'.'.$cluster['id'].'.up.date';
                if (file_exists($log_filename)) {
                    $time[] = file_get_contents($log_filename);
                }
            }
            sort($time);
            if (count($time) > 0) {
                $query['where'].= " AND ".$this->pageTable.".m_date<'{$time[0]}'";
            }
        } else {
            $log_filename = $GLOBALS['egotec_conf']['log_dir'].$this->name.'/live.'.$this->name.'_'.$this->language.'.date';
            if (!file_exists($log_filename)) {
                $log_filename = $GLOBALS['egotec_conf']['log_dir'].$this->name.'/live.date';
            }
            if (file_exists($log_filename)) {
                $live_date = file_get_contents($log_filename);
                $query['where'].= " AND ".$this->pageTable.".m_date<'$live_date'";
            }
        }
 
        $del_pages = $this->getPages($query, array(
            'deleted' => 1,
            'inactive' => true,
            'only_active' => false,
            'no_cache' => 1,
            'rights' => array('delete')
        ));
        while ($page = $del_pages->nextPage()) {
            $page->destroy();
        }
 
        $query['where'] = $original_where;
        $rest = $this->getPages($query, array(
            'deleted' => 1,
            'inactive' => true,
            'only_active' => false,
            'no_cache' => 1
        ));
        $msg = $GLOBALS['auth']->translate("Der Papierkorb wurde geleert.");
        $z = $rest->numRecords();
        if ($z > 0) {
            $msg.= '<p class="warning">'
                . $GLOBALS['auth']->translate("%z Seiten können wegen mangelnder Berechtigung nicht gelöscht werden oder werden beim nächsten Liveabgleich gelöscht.", [
                'z' => $z
            ]) . '</p>';
        }
        return $msg;
    }
 
    public function getPageClass($type = 'page') {
        $cache_key = 'pageClasses';
        if (empty($this->_classes)) {
            $this->_classes = $this->getCacheEntry($cache_key);
        }
        if ($this->_classes === null || !isset($this->_classes[$type])) {
            if (!is_array($this->_classes)) {
                $this->_classes = array();
            }
            $this->_classes[$type] = $this->_getPageClass($type);
            $this->setCacheEntry($cache_key, $this->_classes);
        }
 
        if (!class_exists($this->_classes[$type]['class'], false) && !empty($this->_classes[$type]['file'])) {
            $file = $GLOBALS['egotec_conf']['egotec_dir'].ltrim($this->_classes[$type]['file'], DIRECTORY_SEPARATOR);
            require_once($file);
        }
        return $this->_classes[$type]['class'];
    }
 
    private function _getPageClass($type) {
        $prefix = 'Page' . ($this->conf['page']['prefix'] ?? '');
 
        // Page Erweiterung für den Seitentyp suchen
        $class = $prefix;
        foreach (explode('/', $type) as $part) {
            $class .= ucfirst($part);
        }
 
        // Seitentyp Page Erweiterung suchen
        if ($file = $this->getSiteFile($type.'/page.php', array('module'), true, true)) {
            return array('file' => $file, 'class' => $this->conf['page']['extension'][$class] ?? $class);
        }
 
        // Mandanten Page Erweiterung suchen
        $class = 'Page' . ucfirst($this->name);
        if ($file = $this->getSiteFile('page.php', array('module', 'global', 'parent_theme'), true, true)) {
            return array('file' => $file, 'class' => $class);
        }
 
        // Designvorlage Page Erweiterung suchen (nur in pub/theme/)
        if ($this->theme) {
            $class = 'Page' . implode('', array_map('ucfirst', explode('-', $this->theme)));
            if ($file = $this->getSiteFile('page.php', array('custom', 'global', 'system', 'module', 'parent_custom'), true, true)) {
                return array('file' => $file, 'class' => $class);
            }
        }
 
        // Globale Page Erweiterung suchen
        $class = 'PageGlobal';
        if ($file = $this->getSiteFile('page.php', array('custom', 'system', 'module'), true, true)) {
            return array('file' => $file, 'class' => $class);
        }
 
        // Es gibt keine Page Erweiterung
        return array('file' => '', 'class' => 'Page');
    }
 
    public function updateLinks($output = false) {
        set_time_limit(0);
 
        // Alle alten Verweise löschen
        $this->removeLinks();
 
        $params = array(
            'inactive' => true,
            'only_active' => false,
            'no_cache' => true,
            'auth_or' => '1=1'
        );
 
        $site = clone $this;
        foreach ($this->getLanguages() as $lang) {
            $site->setLanguage($lang);
            foreach ($site->getPages(array(), $params) as $page) {
                if ($output) {
                    Ego_System::flush('.');
                }
                $page->updateLinks(false, true);
            }
        }
    }
 
    public function updateMediaIndex($resume, $c_date, $skipFirst, $dryRun, $timeout) {
        if($this->site['type'] != 'media') {
            echo "Is not a media site\n";
            return;
        }
 
        if ($GLOBALS['egotec_conf']['openoffice']['active'] != 1) {
            echo "index is not active\n";
            return;
        }
 
        require_once('openoffice/openoffice.php');
 
        // kl. Migration auf Sprach Verzeichnisse
        $old_file = $GLOBALS['egotec_conf']['log_dir'].$this->name;
        $new_file = $GLOBALS['egotec_conf']['log_dir'].$this->name."_".$this->language;
 
        if(Ego_System::file_exists($old_file."/index.tmp")) {
            if(!Ego_System::file_exists($new_file."/index.date")) {
                Ego_System::file_put_contents($new_file."/index.date", Ego_System::file_get_contents($old_file."/index.date"));
            }
            @unlink($old_file);
        }
 
        $position = 0;
        if($resume && Ego_System::file_exists($new_file."/index.date")) {
            $position = Ego_System::file_get_contents($new_file."/index.date");
        }
 
        $files = array();
        $addFile = function($path, $entry) use (&$files) {
            if($entry[0] === '.') { // '.' Einträge überspringen
                return;
            }
 
            if(preg_match('/_/', $entry)) { // ein Archiveintrag, wird übersprungen
                return;
            }
            $files[$entry] = filemtime($path.'/'.$entry).' '.$entry;
        };
 
        $path = $GLOBALS['egotec_conf']['var_dir'] . 'media/' . $this->name;
 
        if (!Ego_System::file_exists($path)) {
            // Abbrechen, wenn es das Multimedia Verzeichnis nicht gibt
            return;
        }
 
        // alle direkt unter /media/multimedia/*
        $d = dir($path);
        while (false !== ($entry = $d->read())) {
            if (!is_dir($d->path.'/'.$entry)) {
                $addFile($d->path, $entry);
            }
        }
        $d->close();
 
        // alle direkt unter /media/multimedia/language/*
        if (Ego_System::file_exists($d->path.'/'.$this->language)) {
            $d = dir($d->path.'/'.$this->language);
            while (false !== ($_entry = $d->read()))  {
                $files[$this->language.'/'.$_entry] = filemtime($d->path.'/'.$_entry).' '.$this->language.'/'.$_entry;
            }
            $d->close();
        }
 
        asort($files);
        $startTime = time();
        clearstatcache();
 
        foreach($files as $entry => $fileTime) {
            if($resume && $fileTime <= $position) {
                continue;
            }
 
            $timeRound = strtok($fileTime, ' '); // Den Unixzeitstempel extrahieren.
 
            if ($skipFirst) {
                $skipFirst = false;
                echo "[Fs ] $entry ".date("Y-m-d H:i:s", $timeRound)."\n";
                continue;
            }
 
            $id = preg_replace('/^[^\d]+/', '', $entry);
            if (!is_numeric($id)) {
                continue;
            }
 
            $page = $this->getPage($id, array('inactive' => 1, 'auth_or' => '1=1'));
            if(!$page) {
                echo "[F] $id not found in DB\n";
                continue;
            }
 
            echo "[DS ] ".$entry." ".date("Y-m-d H:i:s", $timeRound)."\n";
 
            $extra = $page->extra;
            $mime_type = $extra['mime_type'];
            $file_ext = $extra['image_type']; // wird von der convert_content benötigt
 
            if (!empty($mime_type)) {
                if (!empty($file_ext)) {
                    $mime_type = Ego_System::getMimeTypes($file_ext);
                } else {
                    continue;
                }
            }
 
            # nur Dateien vom Type ^application oder text... versuchen zu importieren
            if (!preg_match('/^application|text/', $mime_type)) {
                continue;
            }
 
            if (empty($file_ext)) {
                if (!$GLOBALS['mime2ext']) {
                    $GLOBALS['mime2ext'] = array_flip(Ego_System::getMimeTypes());
                }
 
                $file_ext = $GLOBALS['mime2ext'][$mime_type];
            }
 
            $content = convert_content($path . '/' . $entry, $file_ext, $mime_type);
            if(!empty($content)) {
                echo "[FC";
                if(!$dryRun) {
                    try {
                        $page->update(array(
                            'field' => array(
                                'content' => Ego_System::filterNonUtf8($content, '', true)
                            ), TRUE, !$c_date
                        ));
                    } catch(Exception $e) {
                        echo "f] " . $e->getMessage() . "\n";
                        Ego_System::file_put_contents($new_file."/index_error.log", date("Y-m-d H:i:s")." Datei: $entry (".$page->field["name"]."), Datenbankupdate fehlgeschlagen\n", FILE_APPEND);
                    }
                    echo "u] $entry\n";
                    Ego_System::file_put_contents($new_file."/index.log", date("Y-m-d H:i:s")." $entry (".$page->field["name"].".".$extra['image_type'].") [".strlen($content)."]\n", FILE_APPEND);
                } else {
                    echo " ] $entry\n";
                }
            } else {
                echo "[FCf] $entry (mime_type: $mime_type)\n";
                Ego_System::file_put_contents($new_file."/index_error.log", date("Y-m-d H:i:s")." Datei: $entry (".$page->field["name"].".".$extra['image_type']."), konnte nicht konvertiert werden\n", FILE_APPEND);
            }
 
            // position merken
            if(!$dryRun) {
                Ego_System::file_put_contents($new_file."/index.date", $fileTime);
            }
            if ($timeout && time() - $startTime > $timeout) {
                break;
            }
        }
 
        $this->clearCache();
        echo $this->name."_".$this->language." Cache cleared.\n";
    }
 
    public function removeLinks($language = '') {
        $db = new_db_connection();
        if ($language) {
            $db->delete(array(
                'table' => 'egotec_links',
                'where' => 'src_site = :site AND src_lang = :lang',
                'bind' => array(
                    'site' => $this->name,
                    'lang' => $language
                )
            ));
        } else {
            $db->delete(array(
                'table' => 'egotec_links',
                'where' => 'src_site = :site',
                'bind' => array(
                    'site' => $this->name
                )
            ));
        }
    }
 
    public function removeUrls($language = '') {
        $db = new_db_connection();
        $db->begin();
        if ($language) {
            $db->delete(array(
                'table' => 'egotec_url',
                'where' => 'site = :site AND lang = :lang',
                'bind' => array(
                    'site' => $this->name,
                    'lang' => $language
                )
            ));
        } else {
            $db->delete(array(
                'table' => 'egotec_url',
                'where' => 'site = :site',
                'bind' => array(
                    'site' => $this->name
                )
            ));
        }
        $db->commit();
    }
 
    public function updateUrls($reset = false, $verbose = false) {
        if ($reset) {
            // Alle zugehörigen URLs löschen
            $this->removeUrls($this->language);
        }
        if ($root = $this->getRoot(array(
            'auth_or' => '1=1',
            'inactive' => true,
            'only_active' => false
        ))) {
            $root->updateUrls($verbose, null, true);
            unset($GLOBALS['__page_update_urls_stack']); // Den Stack nach jedem Mandanten wieder freigeben
            $this->clearCache();
        }
    }
 
    public function getUnusedPages() {
        if ($this->site['type'] == 'media') {
            return $this->getPages(array(
                'join' => array('egotec_links ON ('
                    .' egotec_links.dest_site = :site'
                    .' AND egotec_links.dest_lang = :lang'
                    .' AND id = egotec_links.dest_id)'),
                'where' => "egotec_links.src_id IS NULL"
                    ." AND deleted = 0"
                    ." AND type IN ('multimedia/file', 'multimedia/image')",
                'bind' => array(
                    'site'  => $this->name,
                    'lang'  => $this->language
                )
            ), array(
                'auth_or' => '1=1',
                'inactive' => 1,
                'only_active' => false,
                'nouse' => true
            ));
        } elseif ($media = $this->getMediaSite()) {
            return $media->getUnusedPages();
        }
        return new Page_Iterator($this);
    }
 
    public function getNonPublicPages($query = [], $param = []) {
        if ($GLOBALS['auth']->isNobody()) {
            // Nicht angemeldete Benutzer erhalten keine Ergebnisse
            return [];
        }
 
        // Limit muss logisch angewendet werden
        if (isset($query['limit'])) {
            [$start, $max] = explode(',', $query['limit']);
            $start = trim($start);
            $max = trim($max);
            unset($query['limit']);
        } else {
            $start = 0;
            $max = 0;
        }
 
        $query['where'] = "({$this->pageTable}_v.c_date > {$this->pageTable}.c_date AND {$this->pageTable}_v.c_user = :this_user)"
            . ($query['where'] ? " AND {$query['where']}" : '');
        $query['bind'] = array_merge($query['bind'] ?? [], [
            'this_user' => $GLOBALS['auth']->user->field['user_id']
        ]);
        $query['fields'] = "{$this->pageTable}.*, {$this->pageTable}_v.id, {$this->pageTable}_v.c_user, MAX({$this->pageTable}_v.c_date) AS v_date"
            . ($query['fields'] ? ", {$query['fields']}" : '');
        $query['inner'] = array_merge($query['inner'] ?? [], [
            "{$this->pageTable}_v ON {$this->pageTable}.id = {$this->pageTable}_v.id"
        ]);
        $query['group'] = "{$this->pageTable}_v.id";
        $query['order'] = $query['order'] ? $query['order'] : "v_date DESC";
 
        $param = array_merge([
            'sitemap' => true,
            'inactive' => true,
            'only_active' => false
        ], $param);
 
        $pages = [];
        $num = 0;
        foreach ($this->getPages($query, $param) as $page) {
            if ($page->isPublicSave()) {
                if ($num >= $start) {
                    $pages[] = $page;
 
                    if ($max > 0 && ($num + 1) == $max) {
                        break;
                    }
                }
 
                $num++;
            }
        }
        return $pages;
    }
 
    public function getCopyrights($start = 0, $limit = 0, &$m = 0) {
        $copyrights = [];
        $n = 0;
        if ($m === null) {
            $m = 0;
        }
 
        // Multimedia Mandanten prüfen
        if ($media = $this->getMediaSite()) {
            $pages = $media->getPages([
                'fields' => $media->pageTable.'.*, egotec_links.src_id',
                'inner' => [
                    'egotec_links ON ' . $media->pageTable . '.id = egotec_links.dest_id'
                ],
                'where' => 'src_site = :src_site AND src_lang = :src_lang AND dest_site = :dest_site',
                'bind' => [
                    'src_site' => $this->name,
                    'src_lang' => $this->language,
                    'dest_site' => $media->name
                ]
            ]);
            foreach ($pages as $page) {
                if ($page->extra['copyright'] !== null) {
                    $n++;
                    if ($limit > 0) {
                        if ($n <= $start) {
                            continue;
                        } elseif (($m + 1) > $limit) {
                            $m++;
                            break;
                        }
                    }
 
                    $key = md5(mb_strtolower($page->extra['copyright']));
 
                    if (!isset($copyrights[$key])) {
                        $copyrights[$key] = [
                            'title' => $page->extra['copyright'],
                            'pages' => []
                        ];
                    }
 
                    $identity = $page->getIdentity();
                    if (!isset($copyrights[$key]['pages'][$identity])) {
                        $copyrights[$key]['pages'][$identity] = [
                            'page' => $page->getIdentity(),
                            'pool' => null,
                            'linked' => []
                        ];
                    }
 
                    if ($link = $this->getPage($page->field['src_id'])) {
                        $copyrights[$key]['pages'][$identity]['linked'][] = [
                            'name' => $link->field['name'],
                            'url' => $link->getUrl()
                        ];
 
                        $m++;
                    }
                }
            }
        }
 
        // Mediapool Dateien prüfen
        if ($this->admin['mediapool']['active']) {
            $pages = $this->getPages();
            foreach ($pages as $page) {
                foreach ($page->getMediapool()->list() as $item) {
                    if ($item['copyright']) {
                        $n++;
                        if ($limit > 0) {
                            if ($n <= $start) {
                                continue;
                            } elseif (($m + 1) > $limit) {
                                $m++;
                                break 2;
                            }
                        }
 
                        $key = md5(mb_strtolower($item['copyright']));
 
                        if (!isset($copyrights[$key])) {
                            $copyrights[$key] = [
                                'title' => $item['copyright'],
                                'pages' => []
                            ];
                        }
 
                        $identity = $item['name'];
                        if (!isset($copyrights[$key]['pages'][$identity])) {
                            $copyrights[$key]['pages'][$identity] = [
                                'page' => $page->getIdentity(),
                                'pool' => $item,
                                'linked' => []
                            ];
                        }
 
                        $copyrights[$key]['pages'][$identity]['linked'][] = [
                            'name' => $page->field['name'],
                            'url' => $page->getUrl()
                        ];
 
                        $m++;
                    }
                }
            }
        }
 
        usort($copyrights, function($a, $b) {
            return strcmp($a['title'], $b['title']);
        });
        return array_values($copyrights);
    }
 
    public function getTemplate($mobile = false, $name = 'index', $dir = '', $variant = '', $suffix = '', $fallback = true) {
        if (empty($suffix)) {
            $suffix = $_SERVER['REQUEST_SUFFIX'];
        }
        $key = 'template'.md5(serialize(array($this->skin, $mobile, $name, $dir, $variant, $suffix, $fallback)));
        $template = $this->getCacheEntry($key);
        if ($template === null) {
            $template = '';
 
            if (!empty($variant)) {
                $variant = ".{$variant}";
            }
            if ($suffix == '.htm') {
                // Bei .htm immer das .pdf Template verwenden
                $suffix = '.pdf';
            }
            $suffix = !in_array($suffix, array('.html', '.php')) ? $suffix : '';
            if ($suffix && $variant == $suffix) {
                $variant = '';
            }
            $base_dir = $dir ? explode('/', $dir)[0] : '';
            foreach (array('.tpl', '.html') as $file_suffix) {
                if (!empty($template)) {
                    break;
                }
                $file = $mobile ? $name . $variant . '.mobile' . $suffix . $file_suffix : $name . $variant . $suffix . $file_suffix;
                if (
                    $base_dir
                    && $name == 'index'
                    && !$this->skin
                    && !$this->theme
                    && ($template_file = $this->getSkinFile($base_dir . '/' . $name . $variant . $file_suffix))
                ) {
                    $template = $template_file;
                } elseif (
                    ($dir && ($template_file = $this->getSkinFile($dir . '/' . $file)))
                    || ($template_file = $this->getSkinFile($file))
                ) {
                    $template = $template_file;
                } elseif ($suffix != '') {
                    $file = $mobile ? $name . $variant . '.mobile' . $suffix . $file_suffix : $name . $variant . $suffix . $file_suffix;
                    if (
                        ($dir && ($template_file = $this->getSkinFile($dir . '/' . $file)))
                        || ($template_file = $this->getSkinFile($file))
                    ) {
                        $template = $template_file;
                    }
                }
            }
            // Es gibt kein Template
            if (empty($template)) {
                if ($mobile) {
                    // Wenn es kein Mobile Template gibt, dann versuchen ein Standard Template zu ermitteln
                    $template = $this->getTemplate(false, $name, $dir, $variant, $suffix, $fallback);
                } elseif ($variant != '' && $suffix != '') {
                    // Wenn es keine Template Variante mit dem Suffix gibt, dann versuchen ohne Variante zu ermitteln
                    $template = $this->getTemplate(false, $name, $dir, '', $suffix, $fallback);
                } elseif ($fallback) {
                    // Das Standard Template verwenden
                    if ($suffix != '') {
                        // Wenn es kein <name>.variant.suffix Template gibt, dann <name>.variant.html verwenden
                        return $this->getTemplate($mobile, $name, $dir, $variant, '.html');
                    } elseif ($variant != '') {
                        // Wenn es kein <name>.variant.html Template gibt, dann <name>.html verwenden
                        return $this->getTemplate($mobile, $name, $dir, '', '.html');
                    } elseif ($name == 'body') {
                        $template_file = $GLOBALS['egotec_conf']['lib_dir'] . 'type/skin/page/body.html';
                        if (Ego_System::file_exists($template_file)) {
                            $template = $template_file;
                        }
                    }
                }
            }
            if (empty($template) && $fallback) {
                throw new Site_Exception('Template does not exist.', Site_Exception::MISSING_TEMPLATE);
            }
            $this->setCacheEntry($key, $template);
        }
        return $template;
    }
 
    public function getSkinFile($path, $skip = array('module'), $url = false, $relative = false) {
        if (!$this->globalAllowed() && !in_array('global', $skip)) {
            // Für diesen Mandanten keine globalen Templates verwenden
            $skip[] = 'global';
        }
        return Ego_System::getFallbackFile('skin', $this->skin, $path, $skip, $url, $relative, $this->theme);
    }
 
    public function getSiteFile($path, $skip = array('module'), $url = false, $relative = false) {
        if (
            !$this->globalAllowed() && !in_array('global', $skip)
        ) {
            // Für diesen Mandanten keine globalen Skripte verwenden
            $skip[] = 'global';
        }
        return Ego_System::getFallbackFile('site', $this->name, $path, $skip, $url, $relative, $this->theme);
    }
 
    public function getFile($path, $type = 'skin') {
        switch ($type) {
            case 'skin':
                return $this->getSkinFile($path, array('module'), true);
            case 'site':
                return $this->getSiteFile($path, array('module'), true);
        }
        return '';
    }
 
    public function getInheritedFile($mode, $type, $path, $skip = array('module'), $url = false, $relative = false) {
        $parts = explode('/', $type);
        while (sizeof($parts) > 0) {
            if (($result = self::{'get' . ucfirst($mode) . 'File'}(implode('/', $parts) . '/' . $path, $skip, $url, $relative)) !== '') {
                return $result;
            }
            array_pop($parts);
        }
        return '';
    }
 
    public function getVariantFiles($path, $skip = array()) {
        $key = 'variant'.md5(serialize(array($path, $skip)));
        $variants = $this->getCacheEntry($key);
        if ($variants === null) {
            $variants = Ego_System::getVariantFiles('skin', $this->skin, $path, $skip, $this->theme);
            $this->setCacheEntry($key, $variants);
        }
        return $variants;
    }
 
    public function getLayoutFiles($path = '', $skip = array(), $conf = array()) {
        $key = 'layout'.md5(serialize(array($path, $skip)));
        $layouts = $this->getCacheEntry($key);
        if ($layouts === null) {
            $layouts = array_merge(
                Ego_System::getFiles('skin', $this->skin, 'layouts/*.tpl', $skip, $this->theme),
                $path != '' ? Ego_System::getFiles('skin', $this->skin, $path.'/layouts/*.tpl', $skip, $this->theme, false, false) : array()
            );
            $layouts = array('default' => $layouts['_empty']) + $layouts;
            if (empty($conf)) {
                $conf = $this->conf['layouts'];
            }
            if (!empty($conf)) {
                foreach ($layouts as $layout => $title) {
                    if (!empty($conf[$layout]['title'])) {
                        $layouts[$layout] = $GLOBALS['auth']->translate($conf[$layout]['title']);
                    }
                }
            }
            unset($layouts['_empty']);
            $this->setCacheEntry($key, $layouts);
        }
        return $layouts;
    }
 
    public function getBlockFiles($path = '', $skip = array()) {
        $key = 'block'.md5(serialize(array($path, $skip)));
        $blocks = $this->getCacheEntry($key);
        if ($blocks === null) {
            $blocks = array_merge(
                Ego_System::getFiles('skin', $this->skin, 'blocks/*.tpl', $skip, $this->theme, false, false),
                $path != '' ? Ego_System::getFiles('skin', $this->skin, $path.'/blocks/*.tpl', $skip, $this->theme, false, false) : array()
            );
            $this->setCacheEntry($key, $blocks);
        }
        return $blocks;
    }
 
    public function isDisabledBlock($block) {
        foreach ([
            $GLOBALS['egotec_conf']['blocks']['design_disabled'],
            $this->admin['blocks']['design_disabled']
        ] as $conf) {
            if (!empty($conf)) {
                $disabled_blocks = explode(',', $conf);
 
                foreach ($disabled_blocks as $disabled_block) {
                    [$name, $key] = explode('/', $disabled_block);
                    if (!empty($key) && $key !== md5(trim(implode(' ', [$this->theme, $this->skin])))) {
                        continue;
                    }
                    if ($name === $block) {
                        return true;
                    }
                }
            }
        }
 
        return false;
    }
 
    public function getEditorTemplates() {
        $templates = array();
        $template_dirs = array(
            array($GLOBALS['egotec_conf']['skin_dir'].$this->skin.'/blocks/', $GLOBALS['egotec_conf']['url_dir'].'skin/'.$this->skin.'/blocks/'),
            $this->globalAllowed() ? array($GLOBALS['egotec_conf']['skin_dir'].'_global/blocks/', $GLOBALS['egotec_conf']['url_dir'].'skin/_global/blocks/') : array()
        );
        if ($this->theme) {
            $template_dirs[] = array($GLOBALS['egotec_conf']['pub_dir']."theme/{$this->theme}/skin/blocks/", $GLOBALS['egotec_conf']['url_dir']."pub/theme/{$this->theme}/skin/blocks/");
        }
        foreach ($template_dirs as $template_dir) {
            if (!empty($template_dir) && Ego_System::file_exists($template_dir[0])) {
                // Alle Templates dieses Verzeichnisses ermitteln
                $dir = dir($template_dir[0]);
                while (($file = $dir->read()) !== false) {
                    if (
                        !in_array($file, array('.', '..'))
                        && preg_match('/^(.*?)\.html$/i', $file, $match)
                    ) {
                        // Bezeichnung
                        $name = $match[1];
 
                        // Pfad
                        $url = $template_dir[1].$file;
 
                        // Beschreibung
                        $description = '';
                        if (Ego_System::file_exists($template_dir[0].$name.'_desc.php')) {
                            // Es existiert eine Beschreibung für dieses Template
                            $description = Ego_System::file_get_contents($template_dir[0].$name.'_desc.php');
                            $description = preg_replace('/(\r\n|\r|\n|\t)/msi', '', strip_tags($description));
                            $description = str_replace("'", "\'", $description);
                        }
 
                        $templates[] = array(
                            'title' => $name,
                            'url' => $url,
                            'description' => $description
                        );
                    }
                }
                $dir->close();
            }
        }
        ksort($templates);
        return $templates;
    }
 
    public function hasLiveserver() {
        return (
            !$GLOBALS['egotec_conf']['liveserver']
            && $this->admin['live']['login']
            && $this->admin['live']['password']
            && ($this->admin['live']['location'] || Ego_System::getCluster($this))
        );
    }
 
    public function getSearchCount($weight = 0) {
        if (!is_numeric($weight)) {
            $weight = 0;
        }
 
        $counts = array();
        $default_counts = array(
            'keywords' => 100,
            'url' => 50,
            'name' => 25,
            'title' => 12,
            'short' => 6,
            'content' => 3,
            'extra' => 1
        );
        foreach ($default_counts as $key => $default_value) {
            $value = (!empty($this->admin['count'][$key]) ? (int)$this->admin['count'][$key] : $default_value) + $weight;
            $counts[$key] = $value > 0 ? $value : 1;
        }
        return $counts;
    }
 
    public function updatePiwikHosts() {
        require_once 'stats/Ego_Piwik.php';
        $piwik = new Ego_Piwik();
        $piwiksites = $this->getPages(array(
            'where' => "extra LIKE '%s:5:\"piwik\"%'"
        ));
        $hosts = $this->getVirtualHosts();
        // Wenn Seiten hinterlegt sind, werden die URLs geupdatet
        if ($piwiksites->numRecords()) {
            foreach ($piwiksites as $psite) {
                if ($psite->extra['piwik']) {
                    if ($psite->extra['piwik']['auth_token'] == 'undefined' && $psite->extra['piwik']['red_id'] == 'undefined') {
                        $piwikdata = $psite->addPiwikSite();
                        $extra = $psite->extra;
                        $extra['piwik'] = $piwikdata;
                        $psite->updateExtra($extra);
                    } else {
                        if (!$psite->extra['piwik']['live_id'] && $this->hasLiveserver()) {
                            $piwikdata = $piwik->createWebsite($psite, true);
                            $extra = $psite->extra;
                            $extra['piwik'] = $piwikdata;
                            $psite->updateExtra($extra);
                        }
 
                        // Hosts aller Sprachverknüpfungen sammeln
                        $language_hosts = $hosts;
                        if (is_array($psite->extra['language_link']) && $psite->extra['language_link'][$this->language]) {
                            foreach ($psite->extra['language_link'] as $lang => $flag) {
                                if ($flag && $lang != $this->language) {
                                    // URLs der Sprachverknüpfung aufnehmen
                                    try {
                                        $lang_site = new Site($this->name, $lang);
 
                                        if ($lang == $psite->extra['language_standard']) {
                                            $language_hosts = array_merge($lang_site->getVirtualHosts(), $language_hosts);
                                        } else {
                                            $language_hosts = array_merge($language_hosts, $lang_site->getVirtualHosts());
                                        }
                                    } catch (Site_Exception $e) {
                                        // ignorieren
                                    }
                                }
                            }
                        }
 
                        $piwik->updateSiteURLs($psite->extra['piwik']['red_id'], $language_hosts, $psite->extra['piwik']['live_id'], $this);
                    }
                }
            }
        } else { // Sind keine hinterlegt wird unterhalb der RootPage eine Statistikseite erstellt (auch für neue Mandanten)
            $new_psite = $this->getRoot();
            if ($new_psite && !$new_psite->extra['do_not_track']) {
                $piwikdata = $new_psite->addPiwikSite();
                $extra = $new_psite->extra;
                $extra['piwik'] = $piwikdata;
                $new_psite->updateExtra($extra);
            }
        }
    }
 
    public function getAdminText($suffix = '', $fallback = true) {
        if ($fallback && !$suffix && $GLOBALS['egotec_conf']['liveserver']) {
            $admin_text = $this->getAdminText('_live', false);
            return $admin_text ? $admin_text : $this->getAdminText('', false);
        }
        if (!empty($this->admin['administration']['admin_text'.$suffix])) {
            return array(
                'text' => $GLOBALS['auth']->translate($this->admin['administration']['admin_text'.$suffix]),
                'url' => (string) $this->admin['administration']['admin_url'.$suffix]
            );
        } elseif (!empty($GLOBALS['egotec_conf']['admin_text'.$suffix])) {
            return array(
                'text' => $GLOBALS['auth']->translate($GLOBALS['egotec_conf']['admin_text'.$suffix]),
                'url' => (string) $GLOBALS['egotec_conf']['admin_url'.$suffix]
            );
        }
        return null;
    }
 
    public function isFrontendAdmin($check_rights = true) {
        return $this->site['type'] == 'content'
            && $this->admin['frontend_admin']
            && (
                !$check_rights
                || (
                    $GLOBALS['auth']
                    && !$GLOBALS['auth']->isNobody()
                )
            );
    }
 
    public function cleanup() {
        $db = new_db_connection();
        if ( in_array(get_class($db), ["Ego_Sql_mssql", "Ego_Sql_oci", "Ego_Sql_sqlite"]) ) {
            return; // TODO make mssql and oracle compatible
        };
        $db->begin();
 
        foreach ($this->getLanguages() as $lang) {
            $pageTable = $this->name.'_'.$lang;
            foreach (array(
                array('_v', 'id', $pageTable, 'id'), // Alle Einträge aus _v entfernen, bei denen id nicht in $pageTable existiert
                array('_children', 'page_id', $pageTable, 'id'), // Alle Einträge aus _children entfernen, bei denen page_id nicht in $pageTable existiert
                array('_rights', 'page_id', $pageTable, 'id'), // Alle Einträge aus _rights entfernen, bei denen page_id nicht in $pageTable existiert
                array('_users', 'page_id', $pageTable, 'id'), // Alle Einträge aus _users entfernen, bei denen page_id nicht in $pageTable existiert
                array('_rights', 'group_id', 'egotec_group', 'group_id'), // Alle Einträge aus _rights entfernen, bei denen group_id nicht in egotec_group existiert
                array('_rights', 'role_id', 'egotec_role', 'role_id'), // Alle Einträge aus _rights entfernen, bei denen role_id nicht in egotec_role existiert
                array('_users', 'user_id', 'egotec_user', 'user_id') // Alle Einträge aus _users entfernen, bei denen user_id nicht in egotec_user existiert
            ) as $v) {
                $db->delete(array(
                    'table' => "{$pageTable}{$v[0]} AS t",
                    'fields' => "t.*",
                    'join' => array("{$v[2]} ON t.{$v[1]} = {$v[2]}.{$v[3]}"),
                    'where' => (in_array($v[1], array('group_id', 'role_id', 'user_id')) ? "t.{$v[1]} != '*' AND " : '')
                        . "{$v[2]}.{$v[3]} IS NULL"
                ));
            }
        }
 
        $db->commit();
    }
 
    public function getNextReplicationDate($page = null) {
        if (
            empty($GLOBALS['egotec_conf']['liveserver']) // Nicht auf dem Liveserver
            && (!$page
                || (($page->field['nav_hide']&2) == 0 // Diese Seite darf übertragen werden
                    && $page->isPublic())) // Diese Seite ist keine Zwischenspeicherung
        ) {
            // Das Datum des letzten Live-/Clusterupdates ermitteln
            $live_date = '';
            if (($clusters = Ego_System::getCluster()) && sizeof($clusters)) {
                // Clusterupdate
                foreach ($clusters as $cluster) {
                    $cluster_date_file = $GLOBALS['egotec_conf']['log_dir'].$this->name.'/live.'.$this->name.'_'.$this->language.'.'.$cluster['id'].'.date';
                    if (Ego_System::file_exists($cluster_date_file)) {
                        $cluster_date = Ego_System::file_get_contents($cluster_date_file);
                        if (!$live_date || $cluster_date > $live_date) {
                            $live_date = $cluster_date;
                        }
                    }
                }
            } else {
                // Liveupdate
                $live_date_file = $GLOBALS['egotec_conf']['log_dir'] . $this->name . '/live.' . $this->name . '_' . $this->language . '.date';
                if (!Ego_System::file_exists($live_date_file)) {
                    $live_date_file = $GLOBALS['egotec_conf']['log_dir'] . $this->name . '/live.date';
                }
                if (Ego_System::file_exists($live_date_file)) {
                    $live_date = Ego_System::file_get_contents($live_date_file);
                }
            }
 
            // Das Datum des letzten Live-/Clusterupdates ist bekannt (und diese Seite wurde seitdem bearbeitet)
            if (!empty($live_date) && (!$page || $page->field['m_date'] > $live_date)) {
                // Prüfen, in welchen (aktiven) Diensten ein Live-/Clusterupdate aktiviert und das Intervall bekannt ist
                $next_date = '';
                require_once 'cron/Ego_Cron.php';
 
                foreach ($this->conf['admin'] as $key => $values) {
                    if (
                        strpos($key, 'cron_') === 0
                        && !empty($GLOBALS['egotec_conf'][$key]['aktiv'])
                        && !empty($GLOBALS['egotec_conf'][$key]['interval'])
                        && (!empty($values['live_incr'])
                            || !empty($values['cluster_incr']))
                    ) {
                        $date = Ego_Cron::getNextDate($GLOBALS['egotec_conf'][$key]['interval'], $page, $live_date);
                        if (empty($next_date) || $date < $next_date) {
                            $next_date = $date;
                        }
                    }
                }
                return $next_date;
            }
        }
        return '';
    }
 
    public function getRewriteConf() {
        $conf = $GLOBALS['egotec_conf']['rewrite'] ?? [];
        if ($this->conf['admin']['rewrite']['overwrite']) {
            $conf = $this->conf['admin']['rewrite'];
            unset($conf['overwrite']);
        }
        return $conf;
    }
 
    public function getSocialNetworks() {
        $networks = array();
 
        // Facebook
        if (!empty($this->admin['social']['facebook_page_id']) && !empty($this->admin['social']['facebook_access_token'])) {
            $networks[] = 'facebook';
        }
 
        // Twitter
        if (!empty($this->admin['social']['twitter_access_token'])) {
            $networks[] = 'twitter';
        }
 
        return $networks;
    }
 
    public function getVirtualHosts() {
        if (empty($this->virtualHosts)) {
            foreach (Ego_System::getVirtualHosts() as $virtual_host => $identity) {
                if (
                    $identity['site'] == $this->name
                    && $identity['lang'] == $this->language
                ) {
                    $this->virtualHosts[] = (string) $virtual_host;
                }
            }
 
            if (empty($this->virtualHosts)) {
                // Gibt es keinen virtuellen Host, wird die Domain automatisch generiert
                $host = $_SERVER['HTTP_HOST'];
                if (!empty($GLOBALS['egotec_conf']['rewrite']['host'])) {
                    $host = $GLOBALS['egotec_conf']['rewrite']['host'];
                }
                $default_host = rtrim($host, '/');
                if ($GLOBALS['egotec_conf']['default_site'] != $this->name) {
                    $default_host .= '/' . $this->name;
                }
                if (sizeof($this->getLanguages()) > 1) {
                    if ($this->language == $this->site['default_language']) {
                        // Die Standardsprache kann auch ohne Sprachangabe aufgerufen werden
                        $this->virtualHosts[] = $default_host;
                    }
                    $default_host .= (strpos($default_host, '/') === false ? '/' : '-') . $this->language;
                }
                $this->virtualHosts[] = $default_host;
            }
        }
        return $this->virtualHosts;
    }
 
    public function globalAllowed() {
        return !$GLOBALS['egotec_conf']['non_global_sites']
            || !in_array($this->name, explode(',', $GLOBALS['egotec_conf']['non_global_sites']));
    }
 
    public function compressFiles($type, $files) {
        $base = 'files/' . md5(serialize([
            $this->name,
            $GLOBALS['egotec_conf']['egotec_version'],
            $GLOBALS['egotec_conf']['project_version']
        ])) . ".$type";
        $path = $GLOBALS['egotec_conf']['pub_dir'] . $base;
 
        if (!Ego_System::file_exists($path)) {
            $content = '';
            foreach ($files as $file) {
                $source = Ego_System::file_get_contents(
                    $absolute = $GLOBALS['egotec_conf']['egotec_dir']
                    . substr($file, mb_strlen($GLOBALS['egotec_conf']['url_dir']))
                );
 
                // Relative Pfade zu absoluten Pfaden umwandeln
                if ($type == 'css') {
                    $source = preg_replace_callback('/(import|url)\s*\‍(["\' ]*(.*?)["\' ]*\‍)/', function($match) use ($absolute) {
                        if ($real = @realpath(dirname($absolute) . '/' . $match[2])) {
                            return str_replace($match[2], substr($real, mb_strlen($GLOBALS['egotec_conf']['egotec_dir']) - 1), $match[0]);
                        }
                        return $match[0];
                    }, $source);
                }
 
                $content .= "\n\n/* ---------- START $file ---------- */\n\n"
                    . $source
                    . "\n\n/* ---------- END $file ---------- */";
            }
 
            Ego_System::file_put_contents($path, trim($content));
        }
 
        return $GLOBALS['egotec_conf']['url_dir'] . 'pub/' . $base;
    }
}