Mediapool.php

gehe zur Dokumentation dieser Datei

<?php
class Mediapool {
    private  $page; 
    private  $site; 
    public  $currentDir = 'current'; 
    public function __construct(Page $page) {
        $this->page = $page;
        $this->site = $this->page->getSite();
    }
 
    public function put($source, $name, $dir = '', $extract = false, $replace = true, $types = '', $save = true, $original = true, $source_extra = array(), &$files = array()) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.put';
        }
 
        if ($original && ($original_page = $this->page->getCloneOriginal())) {
            return $original_page->getMediapool()->put($source, $name, $dir, $extract, $replace, $types);
        }
 
        $result = null;
 
        if ($extract || $this->page->validateFile($source, $name)) {
            // Prüfen, ob dieser Dateityp hochgeladen werden darf
            require_once('base/Ego_MimeType.php');
            $mime = new Ego_MimeType();
            switch ($types) {
                case 'image':
                    if (strpos($mime->autoDetect($source), 'image') !== 0) {
                        return null;
                    }
                    break;
                case 'file':
                    if (strpos($mime->autoDetect($source), 'image') === 0) {
                        return null;
                    }
            }
 
            // Datei hinzufügen
            $this->create();
            $dir = $this->getDir($dir);
            $path = $this->dir()
                . rtrim($dir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
            if (!Ego_System::file_exists($path)) {
                Ego_System::mkdir($path);
            }
            $name = strtr(mb_ereg_replace('[^a-zA-Z0-9\-äöüÄÖÜß()\[\]\.,_ ]', '_', $name), '#?&+', '____'); // Zeichen, die im Namen vorkommen dürfen
            if (!$replace) {
                // Eine Datei mit dem selben Namen nicht überschreiben
                $parts = explode('.', $name, 2);
                $filename = $parts[0];
                $suffix = $parts[1] ? '.' . $parts[1] : '';
                $n = 1;
                while ((bool)$this->file($name, $dir)) {
                    $name = $filename . '_' . ($n++) . $suffix;
                }
            }
            $file = $path . Ego_System::base64Encode($name);
            if ($source !== $file) {
                @unlink($file); // Wegen hard links muss vorher gelöscht werden.
            }
            if (Ego_System::copy($source, $file)) {
                if ($extract) {
                    $this->extract($name, $dir, $files);
                } else {
                    $files[] = $this->get($name, $dir);
                }
 
                // Copyright für Bilder automatisch ermitteln
                $save_copyright = false;
                foreach ($files as $data) {
                    if ($data['isImage']) {
                        require_once('base/Ego_Image.php');
                        $imageTransform = new Ego_Image();
                        try {
                            $imageTransform->load($data['file']);
 
                            $copyright = $imageTransform->getExif(Ego_Image::EXIF_COPYRIGHT);
                            if (trim($copyright) != '') {
                                $data['copyright'] = $copyright;
 
                                if (
                                    $save
                                    || $this->site->conf['admin']['mediapool']['upload_copyright']
                                ) {
                                    $this->setInfo($dir, $data['name'], 'copyright', $copyright);
                                    $save_copyright = true;
                                }
                            }
                        } catch (Ego_Image_Exception $e) {
                            // ignorieren
                        }
                    }
                }
 
                if ($save_copyright) {
                    $this->page->extra['_asis'] = 3;
                }
 
                if (!empty($source_extra)) {
                    foreach ($source_extra as $key => $value) {
                        $this->setInfo($dir, $name, $key, $value);
                    }
                    $this->page->extra['_asis'] = 5; // asis 5 = Extra Feld für Media kopiert
                }
 
                $data['extra'] = $this->page->extra['mediapool'];
                if ($save_copyright || !empty($source_extra)) {
                    $this->page->update(array(), true, true);
                }
 
                $result = $data;
            }
        }
 
        $this->page->replicate('pool.put', "@file:$source", $name, $dir, $extract, $replace, $types, $save, $original);
 
        return $result;
    }
 
    public function duplicate($name, $dir = '') {
        $item = $this->get($name, $dir);
        if (!empty($item)) {
            return $this->put($item['file'], $name, $dir, false, false, '', true, true, $item['extra']);
        }
        return null;
    }
 
    public function extract($name, $dir = '', &$files = []) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.extract';
        }
 
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->extract($name, $dir);
        }
        $dir = $this->getDir($dir);
        $path = $this->dir();
        $file = $this->file($name, $dir);
        if ($file) {
            $tmp_file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'ZIP_').'.zip';
            if (Ego_System::copy($file, $tmp_file)) {
                require_once('media/functions.php');
                if (preg_match('/\.gz$/msi', $name)) {
                    require_once('Archive/Tar.php');
                    $zip = new Archive_Tar($tmp_file);
                } else {
                    require_once('Archive/Zip.php');
                    $zip = new Archive_Zip($tmp_file);
                }
                $cwd = getcwd();
                chdir($path.$dir);
                @set_time_limit(0);
                $list = $zip->extract();
                @unlink($file);
                @unlink($tmp_file);
                chdir($cwd);
                if (is_array($list)) {
                    $main_dir = '';
                    foreach ($list as $info) {
                        $info_dir = $path
                            .rtrim($dir, DIRECTORY_SEPARATOR)
                            .DIRECTORY_SEPARATOR.$info['stored_filename'];
                        if (!is_dir($info_dir)) {
                            if ($this->page->validateFile($info_dir)) {
                                $info_name = Ego_System::base64Encode(basename($info['stored_filename']));
                                @rename(
                                    $info_dir,
                                    $path
                                    . rtrim($dir, DIRECTORY_SEPARATOR)
                                    . DIRECTORY_SEPARATOR . $info_name
                                );
 
                                // Alle Dateien im Archiv merken
                                $files[] = $this->get(basename($info['stored_filename']), $dir);
                            } else {
                                @unlink($info_dir);
                            }
                        } elseif ($main_dir == '' || strlen($info_dir) < strlen($main_dir)) {
                            $main_dir = $info_dir;
                        }
                    }
                    if ($main_dir != '') {
                        Ego_System::deldir($main_dir);
                    }
 
                    $this->page->replicate("pool.extract", $name, $dir);
 
                    return true;
                } elseif ($list === true) {
                    // TODO Tar liefert keine Liste der entpackten Dateien
                    return true;
                }
            }
        }
 
        return false;
    }
 
    public function get($name, $dir = '', $params = array(), $decoded = false, $block = '') {
        $dir = $this->getDir($dir);
        $params['pool'] = $name;
        $file = $this->file($name, $dir, $convert);
        $name_key = md5(!empty($convert) ? $convert['name'] : $name);
        $sub_dir = $this->subDir($dir);
        if (!$file) {
            if (!$decoded) {
                // Fallback, falls der Name kodiert übergeben, aber nicht kodiert gespeichert wurde
                return $this->get(urldecode($name), $dir, $params, true);
            }
            return array();
        }
 
        $suffix = '';
        if (preg_match('/\.([^\.]+)$/ims', $name, $match)) {
            $suffix = strtolower($match[1]);
        }
 
        // Mime-Type der Datei
        require_once 'base/Ego_MimeType.php';
        $mime = new Ego_MimeType();
        $mime_type = !empty($convert)
            ? $convert['mime']
            : ($mime->byExtension($suffix) ?? $mime->autoDetect($file));
 
        if (
            (!empty($suffix) && $ext = $suffix)
            || ($ext = $mime->getExtension($mime_type))
        ) {
            $isImage = in_array($ext, Ego_System::getFormats('image'));
            $isArchive = in_array($ext, Ego_System::getFormats('archive'));
            $isVideo = in_array($ext, Ego_System::getFormats('video'));
        }
        $sub_data = array();
 
        $width = $height = null;
        if ($info = Ego_System::getFileInfo($file)) {
            $width = $info['width'];
            $height = $info['height'];
            if ($isImage) {
                $params['width'] = $width ?: null;
                $params['height'] = $height ?: null;
            }
            if (isset($info['duration'])) {
                $sub_data['duration'] = $info['duration'];
            }
        }
        if ((string) $dir != (string) $this->currentDir) {
            $params['dir'] = $this->subDir($dir);
        }
        $params['site'] = $this->site->name;
        $params['lang'] = $this->site->language;
        $params['id'] = $this->page->field['id'];
 
        // Download URL ohne width und height
        $download_params = $params;
        $download_params['download'] = 1;
        unset($download_params['width'], $download_params['height']);
 
        // Titel bestimmen
        $title = empty($params['no_auto_title']) ? $name : '';
        if ($extra_title = (string) ($this->page->extra['mediapool'][md5($sub_dir)][$name_key]['title'])) {
            $title = $extra_title;
        } elseif ($pos = strrpos($title, '.')) {
            $title = substr($title, 0, $pos);
        }
 
        // Zusätzliche Eigenschaften
        $extra = array();
        if ($block) {
            $extra_key = 'block.' . $block;
        } else {
            $extra_key = ($sub = strrchr($dir, DIRECTORY_SEPARATOR)) ? substr($sub, 1) : 'default';
        }
        if ($this->page->conf['mediapool'][$extra_key]['extra']) {
            foreach ($this->page->conf['mediapool'][$extra_key]['extra'] as $field) {
                $extra[$field['name']] = $this->page->extra['mediapool'][md5($sub_dir)][$name_key][$field['name']];
            }
        }
 
        $get_url = function($params) {
            unset($params['mime_type']);
            return 'index.php?' . str_replace('%2F', '/', http_build_query($params));
        };
 
        $isUsed = false;
        if ($dir === '') {
            $pattern = '/([.?*+^$[\]\\(){}|-])/';
            $name1 = str_replace($pattern, '\\$1', $name);
            $name2 = str_replace($pattern, '\\$1', str_replace('/%20/', '+', urlencode($name)));
            $name3 = str_replace(['/\‍(/', '/\‍)/'], ['%28', '%29'], $name2); // TODO auch andere Zeichen als () berücksichtigen
            $regex = '/([?&-]pool[=-]|\/_\/)('
                . preg_quote($name1, '/')
                . '|' . preg_quote($name2, '/')
                . '|' . preg_quote($name3, '/')
                . ')/';
            foreach (['content', 'short', 'extra'] as $key) {
                if (preg_match($regex, $this->page->field[$key])) {
                    $isUsed = true;
                    break;
                }
            }
        }
 
        // Alle ignorierten Konvertierungen
        $convert_ignore = array_filter(explode(',', (string) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['convert_ignore']));
        sort($convert_ignore);
 
        // Alle verfügbaren Konvertierungen
        if (!empty($params['get_formats']) && $isImage) {
            unset($params['get_formats'], $download_params['get_formats']);
            require_once 'base/Ego_Output.php';
            $output = new Ego_Output($this->page, $name, $dir);
            $sub_data['converted_files'] = array_filter($output->getConvertedImages(), function($file) use ($convert_ignore) {
                return !in_array($file['format'], $convert_ignore);
            });
            $sub_data['converted_files'] = array_map(function($file) use (&$params, &$get_url) {
                $file['url'] = $get_url(array_merge($params, ['suffix' => $file['format'], 'inactive' => 1, 'preview' => 1]));
                return $file;
            }, $sub_data['converted_files']);
        }
 
        $data = array_merge(array(
            'identity' => $this->page->getIdentity(),
            'name' => $name,
            'key' => md5($name),
            'file' => $file,
            'url' => $get_url($params),
            'download' => $get_url($download_params),
            'convert' => !empty($convert),
            'size' => @filesize($file),
            'mime' => $mime_type,
            'width' => $width,
            'height' => $height,
            'suffix' => $suffix,
            'isImage' => $isImage,
            'isArchive' => $isArchive,
            'isVideo' => $isVideo,
            'isUsed' => $isUsed,
            'lastChange' => @filemtime($file),
            'title' => $title,
            'description' => (string) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['description'],
            'copyright' => (string) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['copyright'],
            'order' => (int) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['order'],
            'nav_hide' => (int) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['nav_hide'],
            'clip' => $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['clip'],
            'rotation' => (int) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['rotation'],
            'mirror' => (string) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['mirror'],
            'grayscale' => (string) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['grayscale'],
            'quarantine' => (bool) $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['quarantine'],
            'convertIgnore' => $convert_ignore,
            'vtt' => $this->page->extra['mediapool'][md5($sub_dir)][$name_key]['vtt'],
            'extra' => $extra,
            'extra_key' => implode('.', ['mediapool', md5($sub_dir), $name_key])
        ), $sub_data);
        return $data;
    }
 
    public function file($name, $dir = '', &$convert = []) {
        $dir = $this->getDir($dir);
        $file = $this->dir()
            .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.Ego_System::base64Encode($name);
        if (Ego_System::file_exists($file)) {
            return $file;
        } else {
            // Abwärtskompatibilität zu alten base64 Strings
            $file = $this->dir()
                .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.base64_encode($name);
            if (Ego_System::file_exists($file)) {
                return $file;
            }
        }
 
        // Datei könnte eine dynamisch umwandelbare Datei sein
        require_once 'base/Ego_Output.php';
        foreach (Ego_Output::$convert_types as $type => $info) {
            if (
                ($matches = preg_split('/\.' . preg_quote($type, '/') . '$/i', $name, 2))
                && sizeof($matches) > 1
            ) {
                $basename = preg_quote($matches[0], '/');
                $convertable_file = $this->first('/^' . $basename . '\..*?$/', $dir, $found);
                if ($convertable_file) {
                    $convert = [
                        'name' => $found,
                        'convert' => $type,
                        'mime' => $info['mime']
                    ];
                }
                return $convertable_file;
            }
        }
 
        return null;
    }
 
    private function first($pattern, $dir = '', &$found = '') {
        $dir = $this->getDir($dir);
        $folder = $this->dir()
            .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        if (Ego_System::file_exists($folder)) {
            $d = dir($folder);
            $path = null;
            while (($file = $d->read()) !== false) {
                if (
                    preg_match($pattern, ($decoded = Ego_System::base64Decode($file)))
                    || preg_match($pattern, ($decoded = base64_decode($file)))
                ) {
                    $found = $decoded;
                    $path = $folder.$file;
                    break;
                }
            }
            $d->close();
            return $path;
        }
        return null;
    }
 
    public function delete($name, $dir = '', $replication = true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.delete';
        }
 
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->delete($name, $dir);
        }
        $dir = $this->getDir($dir);
        $file = $this->dir()
            .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.Ego_System::base64Encode($name);
        if (!Ego_System::file_exists($file)) {
            // Abwärtskompatibilität zu alten base64 Strings
            $file = $this->dir()
                .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.base64_encode($name);
        }
 
        // Umgewandelte Dateien löschen
        require_once 'base/Ego_Output.php';
        $output = new Ego_Output($this->page, $name, $dir);
        $output->clearConvertedImages();
 
        if (
            (is_dir($file) && Ego_System::deldir($file))
            || @unlink($file)
        ) {
            if ($dir == $this->currentDir) {
                $this->page->update();
            }
 
            if ($replication) {
                $this->page->replicate("pool.delete", $name, $dir);
            }
 
            return true;
        }
 
        return false;
    }
 
    public function edit($name, $params = array(), $dir = '') {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.edit';
        }
 
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->put($name, $params, $dir);
        }
        $dir = $this->getDir($dir);
        $file = $params['new_file'] ?: $this->file($name, $dir);
        $sub_dir = $this->subDir($dir);
        $new_name = trim($params['new_name']);
 
        if (
            !empty($file)
            && !empty($new_name)
            && $name != $new_name
            && ($data = $this->put($file, $new_name, $dir, false, (bool) $params['replace']))
        ) {
            if ($this->delete($name, $dir, false)) {
                // Alle Verweise auf den originalen Namen ändern
                $this->page->field['content'] = $this->renameRecursive($name, $new_name, $this->page->field['content']);
                $this->page->field['short'] = $this->renameRecursive($name, $new_name, $this->page->field['short']);
                $this->page->extra = $this->renameRecursive($name, $new_name, $this->page->extra);
                $this->page->extra['mediapool'][md5($sub_dir)][md5($new_name)] = $this->page->extra['mediapool'][md5($sub_dir)][md5($name)];
                unset($this->page->extra['mediapool'][md5($sub_dir)][md5($name)]);
                $name = $new_name;
            } else {
                // Änderungen zurücksetzen
                $this->delete($new_name, $dir);
                return false;
            }
        }
        // Hinzufügen der Datei in das Extra-Feld der Seite
        if (empty($this->page->extra['mediapool'][md5($sub_dir)][md5($name)])) {
            $this->page->extra['mediapool'][md5($sub_dir)][md5($name)] = array();
        }
 
        unset($params['new_name'], $params['replace']);
        $this->page->extra['mediapool'][md5($sub_dir)][md5($name)] = array_merge($this->page->extra['mediapool'][md5($sub_dir)][md5($name)], $params);
 
        $this->page->replicate("pool.edit", $name, $params, $dir);
 
        $this->page->update(array(
            'field' => array(
                'content' => $this->page->field['content'],
                'short' => $this->page->field['short']
            ),
            'extra' => $this->page->extra
        ), true, true);
 
        return true;
    }
 
    private function renameRecursive($name, $new_name, $value) {
        if (is_array($value)) {
            foreach ($value as $key => $v) {
                $value[$key] = $this->renameRecursive($name, $new_name, $value[$key]);
            }
        } elseif (preg_match_all('/index\.php\?[^>"]+/ims', $value, $matches)) {
            $encode = function($s) {
                return str_replace(' ', '+', $s);
            };
            foreach ($matches[0] as $match) {
                $new_url = preg_replace('/([&?])pool='.preg_quote($encode($name), '/').'/msi', '$1pool='.$encode($new_name), $match);
                $value = str_replace($match, $new_url, $value);
            }
        }
        return $value;
    }
 
    public function list($dir = '', $params = array(), $block = '') {
        $dir = $this->getDir($dir);
        $list = array();
        $path = $this->dir()
            .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        if (Ego_System::file_exists($path)) {
            if ($handle = opendir($path)) {
                $params2 = $params;
                unset(
                    $params2['sort_field'],
                    $params2['sort_reverse'],
                    $params2['search'],
                    $params2['only_image']
                );
                while (false !== ($file = readdir($handle))) {
                    if ($file != '.' && $file != '..' && !is_dir($path.$file)) {
                        $data = $this->get(Ego_System::base64Decode($file), $dir, $params2, false, $block);
                        if (
                            !empty($data)
                            && (
                                (
                                    !$params['only_image']
                                    && !$_REQUEST['session']['insert_image']
                                )
                                || $data['isImage']
                            )
                            && (
                                (
                                    !$params['only_video']
                                    && !$_REQUEST['session']['insert_video']
                                )
                                || $data['isVideo']
                            )
                            && (
                                (
                                    !$params['only_file']
                                    && !$_REQUEST['session']['insert_file']
                                )
                                || !$data['isImage']
                            )
                            && (
                                (
                                    !$params['only_media']
                                    && !$_REQUEST['session']['insert_media']
                                )
                                || $data['isImage']
                                || $data['isVideo']
                            )
                            && (
                                empty($params['mime_type'])
                                || preg_match('#'.$params['mime_type'].'#i', $data['mime'])
                            )
                            && (
                                empty($params['search'])
                                || stripos($data['name'], $params['search']) !== false
                                || stripos($data['title'], $params['search']) !== false
                            )
                        ) {
                            if ($this->site->admin['mediapool']['video_compress'] && $data['mime'] === 'video/mp4') {
                                foreach (Ego_System::VIDEO_RESOLUTIONS as $height => $scale) {
                                    $data['compressed_files'][str_replace(':', ' x ', $scale)] = $this->get("{$data['title']}_{$height}p.mp4", '_compress');
                                }
                            }
 
                            $list[] = $data;
                        }
                    }
                }
                closedir($handle);
            }
        }
        if (!empty($list)) {
            $sort = array();
            $names = array();
            foreach ($list as $file) {
                $sort_field = ($params['sort_field'] && isset($file[$params['sort_field']]))
                    ? $file[$params['sort_field']]
                    : $file['order'];
                $sort[] = is_string($sort_field)
                    ? mb_strtolower($sort_field)
                    : $sort_field;
                $names[] = mb_strtolower($file['name']);
            }
            if (!$params['sort_field'] && sizeof(array_unique($sort)) == 1) {
                // Standardmäßig nach Namen sortieren
                array_multisort(
                    $names,
                    $params['sort_reverse'] ? SORT_DESC : SORT_ASC,
                    SORT_STRING,
                    $list
                );
            } else {
                // Individuelle Sortierung
                array_multisort(
                    $sort,
                    $params['sort_reverse'] ? SORT_DESC : SORT_ASC,
                    is_string($sort_field) ? SORT_STRING : SORT_NUMERIC,
                    $list
                );
            }
        }
        if (isset($params['start'])) {
            // Einen Teil ausgeben
            $list = array_slice($list, $params['start'], $params['end']);
        }
        return $list;
    }
 
    public function getDirs($archives = false) {
        $dirs = [];
 
        foreach (glob($this->dir() . '*', GLOB_ONLYDIR) as $path) {
            $dir = basename($path);
            if ($dir == $this->currentDir) {
                $dirs[] = '';
            } elseif (!is_numeric($dir) || $archives) {
                $dirs[] = $dir;
            }
        }
 
        return $dirs;
    }
 
    public function setInfo($dir, $name, $key, $value = null) {
        $sub_dir = $this->subDir($dir);
        if ($value === null) {
            unset($this->page->extra['mediapool'][md5($sub_dir)][md5($name)][$key]);
        } else {
            $this->page->extra['mediapool'][md5($sub_dir)][md5($name)][$key] = $value;
        }
        return implode('.', array('mediapool', md5($sub_dir), md5($name), $key));
    }
 
    public function dir($relative = false, $source = null) {
        if ($source) {
            $site = $source->getSite();
            $name = $site->name;
            $lang = $site->language;
            $id = $source->field['id'];
        } else {
            $name = $this->site->name;
            $lang = $this->site->language;
            $id = $this->page->field['id'];
        }
        return (!$relative ? $GLOBALS['egotec_conf']['var_dir'] : '').'media'.
            DIRECTORY_SEPARATOR.$name.
            DIRECTORY_SEPARATOR.$lang.
            DIRECTORY_SEPARATOR. 'pool' .
            DIRECTORY_SEPARATOR.$id.
            DIRECTORY_SEPARATOR;
    }
 
    private function subDir($dir) {
        $sub_dir = '';
        if ($dirs = explode(DIRECTORY_SEPARATOR, $dir)) {
            if ($dirs[0] == $this->currentDir) {
                unset($dirs[0]);
            }
            $sub_dir = implode(DIRECTORY_SEPARATOR, $dirs);
        }
        return $sub_dir;
    }
 
    private function getDir($dir) {
        if (is_numeric(explode(DIRECTORY_SEPARATOR, $dir)[0])) {
            // Archive sind niemals Unterverzeichnisse
            return $dir;
        } elseif (empty($dir) || $dir == $this->currentDir) {
            // Standard Verzeichnis
            return $this->currentDir;
        }
        // Unterverzeichnis
        return $this->currentDir . DIRECTORY_SEPARATOR . $this->subDir($dir);
    }
 
    public function archive($c_date, $dir = '') {
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->archive($c_date, $dir);
        }
        $dir = $this->getDir($dir);
        $path = $this->dir();
        if (Ego_System::file_exists($path)) {
            $src = $path.rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
            $dest = $path.($dir != $this->currentDir ? $dir : '')
                .Ego_System::dateEncode($c_date).DIRECTORY_SEPARATOR;
            Ego_System::deldir($dest); // Archiv vorher löschen, falls es bereits existiert
            return Ego_System::copy($src, $dest, '', true); // Kopie mit hard links
        }
        return false;
    }
 
    public function restore($c_date, $name = '', $dir = '') {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.restore';
        }
 
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->restore($c_date, $name, $dir);
        }
        if (!empty($c_date)) {
            $dir = $this->getDir($dir);
            if (empty($name)) {
                // Gesamten Mediapool wiederherstellen
                $dest = $this->dir()
                    .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
                $source = $this->dir().$c_date.DIRECTORY_SEPARATOR;
                if (
                    Ego_System::file_exists($source)
                    && Ego_System::file_exists($dest)
                ) {
                    $archive_page = $this->page->getArchivePage(is_numeric($c_date) ? date('Y-m-d H:i:s', $c_date) : $c_date);
                    $mediapool = $archive_page ? $archive_page->extra['mediapool'] : array();
                    $this->clear($dir, $mediapool);
 
                    $this->page->replicate("pool.restore", $c_date, $name, $dir);
 
                    return Ego_System::copy($source, $dest, '', false, false, true);
                }
            } else {
                // Eine Datei im Mediapool wiederherstellen
                $path = $dir == $this->currentDir
                    ? $c_date
                    : rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.$c_date;
                $source = $this->get($name, $path);
 
                $this->page->replicate("pool.restore", $c_date, $name, $dir);
 
                return (bool) $this->put($source['file'], $name, $dir);
            }
        }
 
        return false;
    }
 
    private function create() {
        $dir = $this->dir();
        if (!Ego_System::file_exists($dir)) {
            Ego_System::mkdir($dir);
        }
    }
 
    public function copy(Page $target, $dir = '', $clear = false, $integrate = false, $archive = true, $asis = true, $specific_sub_dir = false, $rename = '', $matrix = true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.copy';
        }
 
        $path = $this->dir();
 
        // Wenn ein bestimmter Unterordner selektiert werden soll, muss man noch das currentDir ergänzen damit der Pfad stimmt
        if ($specific_sub_dir) {
            $path .= $this->currentDir.DIRECTORY_SEPARATOR;
        }
 
        if (!empty($dir)) {
            $path .= rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        }
 
        if (Ego_System::file_exists($path)) {
            // Original kopieren
            $dest = $this->dir(false, $target);
 
            // Wenn ein bestimmter Unterordner selektiert werden soll, muss man noch das currentDir ergänzen damit der Pfad stimmt
            if ($specific_sub_dir) {
                $dest .= $this->currentDir.DIRECTORY_SEPARATOR;
            }
 
            if (!empty($dir)) {
                $dest .= rtrim($rename ?: $dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
            }
 
            if (!$integrate && $this->page->getIdentity() != $target->getIdentity()) {
                Ego_System::deldir($dest);
            }
 
            $this->page->replicate("pool.copy", $target, $dir, $clear, $integrate, $archive, $asis);
 
            Ego_System::copy($path, $dest, ($archive ? '' : '/^\d+$/'), true); // Hard Links erstellen
 
            // Verweise anpassen
            $target->getMediapool()->import(true, true, $dir, true, $asis, $rename, $matrix);
 
            /* Wichtig: Nur wenn die Sprachmatrix berücksichtigt wird!
             * Andernfalls wurde die Sprachmatrix bereits vorher berücksichtigt und die Mediapool Informationen (ggf. übersetzt) kopiert
             * @see Page._update */
            if ($matrix) {
                if (!empty($dir)) {
                    $target->extra['mediapool'][md5($dir)] = $this->page->extra['mediapool'][md5($dir)];
                } else {
                    $target->extra['mediapool'] = $this->page->extra['mediapool'];
                }
                $target->extra['_asis'] = 5;
                $target->update(array(), $matrix, true);
            }
 
            // Original löschen
            if ($clear) {
                $this->clear($dir);
            }
        }
    }
 
    public function move($target, $dir = '', $integrate = false, $archive = true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.move';
        }
 
        $this->copy($target, $dir, true, $integrate, $archive);
 
        $this->page->replicate("pool.move", $target, $dir, $integrate, $archive);
    }
 
    public function exists($dir = '', $empty = true) {
        $dir = $this->getDir($dir);
        $path = $this->dir()
            .rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        return Ego_System::file_exists($path) && ($empty || sizeof(is_array($scanned_dir = scandir($path)) ? $scanned_dir : []) > 2);
    }
 
    public function clear($dir = '', $mediapool = array(), $update = true) {
        if (!isset($GLOBALS['__egotec_skip_replication'])) {
            $GLOBALS['__egotec_skip_replication'] = 'pool.clear';
        }
 
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->clear($dir);
        }
        $path = $this->dir();
        if (!empty($dir)) {
            $path .= rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        }
        $sub_dir = $this->subDir($dir);
 
        // Zusätzliche Informationen zu diesem Mediapool löschen/setzen
        if (!empty($mediapool)) {
            $this->page->extra['mediapool'] = $mediapool;
        } else {
            unset($this->page->extra['mediapool'][md5($sub_dir)]);
        }
        if ($update) {
            $this->page->update(array(), true, true);
        }
 
        $this->page->replicate("pool.clear", $dir, $mediapool, $update);
 
        Ego_System::deldir($path);
    }
 
    public function import($only_pool = false, $replace = false, $dir = '', $update = true, $asis = true, $rename = '', $matrix = true) {
        $this->page->field['content'] = $this->importRecursive($this->page->field['content'], $only_pool, $replace, $dir, $rename);
        $this->page->field['short'] = $this->importRecursive($this->page->field['short'], $only_pool, $replace, $dir, $rename);
        $this->page->extra = $this->importRecursive($this->page->extra, $only_pool, $replace, $dir, $rename);
        if ($update) {
            $this->page->update(array(
                'field' => array(
                    'content' => $this->page->field['content'],
                    'short' => $this->page->field['short']
                ),
                'extra' => $this->page->extra
            ), $matrix, $asis);
        }
    }
 
    private function importRecursive($value, $only_pool = false, $replace = false, $dir = '', $rename = '') {
        if (is_array($value)) {
            foreach ($value as $key => $v) {
                $value[$key] = $this->importRecursive($v, $only_pool, $replace, $dir, $rename);
            }
        } elseif (preg_match_all('/index\.php\?[^>"\\\]+/ims', $value, $matches)) {
            $dir = $dir == '' ? '' : rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
            foreach ($matches[0] as $url) {
                $page = Ego_System::urltopage($url, array(
                    'params' => array(
                        'param' => array(
                            'auth_or' => '1=1',
                            'deleted_or' => '1=1',
                            'inactive' => true,
                            'only_active' => false
                        )
                    )
                ));
                $info = Ego_System::getUrlInfo($url);
                if ($page) {
                    if (
                        !$only_pool
                        && in_array($page->field['type'], array('multimedia/file', 'multimedia/image'))
                    ) {
                        // Multimedia
                        $site = $page->getSite();
                        $path = $GLOBALS['egotec_conf']['var_dir'].'media/'.$site->name.'/';
                        $file = $path.$page->getMediaFilename();
                        if (Ego_System::file_exists($file)) {
                            $name = $page->field['name'];
                            $suffix = '';
                            if ($page->extra['image_type']) {
                                $suffix = '.'.$page->extra['image_type'];
                            }
                            if (!$replace) {
                                while ($this->file($name.$suffix, $dir)) {
                                    // Eine Datei mit dem selben Namen existiert bereits
                                    if (preg_match('/_(\d+)$/ims', $name, $match)) {
                                        $num = ((int) $match[1]) + 1;
                                        $name = preg_replace('/_\d+$/ims', '', $name);
                                    } else {
                                        $num = 1;
                                    }
                                    $name .= '_'.$num;
                                }
                            }
                            $media = $this->put($file, $name.$suffix, $rename ?: $dir);
                            if (!empty($media['url'])) {
                                $value = str_replace($url, $media['url'], $value);
                            }
                        }
                    } elseif (!empty($info['params']['pool'])) {
                        // Mediapool
                        $media = $page->getMediapool()->get(urldecode($info['params']['pool']), $dir);
                        if ($media['file']) {
                            $media = $this->put(
                                $media['file'],
                                $media['name'],
                                $rename ?: $dir,
                                false,
                                $replace,
                                '',
                                true,
                                !$this->page->isClone() // Beim Import in einen Klon, werden die Mediapool URLs auf den Klon umgeschrieben
                            );
                        }
                        if (!empty($media['url'])) {
                            $value = str_replace($url, $media['url'] . (!empty($info['params']['clip']) ? "&clip=" . $info['params']['clip'] : ""), $value);
                        }
                    }
                }
            }
        }
        return $value;
    }
 
    public function getQuarantine() {
        $files = [];
 
        if (is_array($this->page->extra['mediapool'])) {
            $recursive = function($dir, $sub = '') use (&$recursive, &$files) {
                $d = @dir($dir);
                if ($d !== false) {
                    while (($entry = $d->read()) !== false) {
                        if ($entry[0] != '.' && $entry == 'current') {
                            $sub_dir = rtrim($dir) . DIRECTORY_SEPARATOR . $entry;
                            if (is_dir($sub_dir)) {
                                $recursive($sub_dir, ($sub ? $sub . DIRECTORY_SEPARATOR : '') . $entry);
                            } else {
                                $info = $this->get(Ego_System::base64Decode($entry), $sub);
                                if ($info && $info['quarantine']) {
                                    $files[] = ($sub ? $sub . DIRECTORY_SEPARATOR : '') . basename($info['file']);
                                }
                            }
                        }
                    }
                    $d->close();
                }
            };
            $recursive($this->dir());
        }
 
        return $files;
    }
 
    public function getPage() {
        return $this->page;
    }
 
    public function getSite() {
        return $this->site;
    }
}