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) {
        if ($original && ($original_page = $this->page->getCloneOriginal())) {
            return $original_page->getMediapool()->put($source, $name, $dir, $extract, $replace, $types);
        }
        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);
                }

                $data = $this->get($name, $dir);

                // Copyright für Bilder automatisch ermitteln
                if ($data['isImage']) {
                    require_once('base/Ego_Image.php');
                    $imageTransform = new Ego_Image();
                    $imageTransform->load($file);

                    $copyright = $imageTransform->getExif(Ego_Image::EXIF_COPYRIGHT);
                    if (trim($copyright) != '') {
                        $data['copyright'] = $copyright;

                        if ($save) {
                            $this->setInfo($dir, $name, 'copyright', $copyright);
                            $this->page->update(array(), true, true);
                        }
                    }
                }

                return $data;
            }
        }
        return null;
    }

    public function extract($name, $dir = '') {
        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
                                );
                            } 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);
                    }
                    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);
        $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();
        }

        // Mime-Type der Datei
        require_once 'base/Ego_MimeType.php';
        $mime = new Ego_MimeType();
        $mime_type = $mime->autoDetect($file);

        $suffix = '';
        if (preg_match('/\.([^\.]+)$/ims', $name, $match)) {
            $suffix = strtolower($match[1]);
        }
        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;
                $params['height'] = $height;
            }
            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 = $name;
        if ($extra_title = (string) ($this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['title'])) {
            $title = $extra_title;
        } elseif ($pos = strrpos($name, '.')) {
            $title = substr($name, 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)][md5($name)][$field['name']];
            }
        }

        $get_url = function($params) {
            unset($params['mime_type']);
            return 'index.php?' . str_replace('%2F', '/', http_build_query($params));
        };

        $data = array_merge(array(
            'name' => $name,
            'file' => $file,
            'url' => $get_url($params),
            'download' => $get_url($download_params),
            'size' => @filesize($file),
            'mime' => $mime_type,
            'width' => $width,
            'height' => $height,
            'suffix' => $suffix,
            'isImage' => $isImage,
            'isArchive' => $isArchive,
            'isVideo' => $isVideo,
            'lastChange' => @filemtime($file),
            'title' => $title,
            'description' => (string) $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['description'],
            'copyright' => (string) $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['copyright'],
            'order' => (int) $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['order'],
            'clip' => $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['clip'],
            'rotation' => (int) $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['rotation'],
            'mirror' => (string) $this->page->extra['mediapool'][md5($sub_dir)][md5($name)]['mirror'],
            'extra' => $extra
        ), $sub_data);
        return $data;
    }

    public function file($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)) {
            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;
            }
        }
        return null;
    }

    public function delete($name, $dir = '') {
        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);
        }

        if (
            (is_dir($file) && Ego_System::deldir($file))
            || @unlink($file)
        ) {
            if ($dir == $this->currentDir) {
                $this->page->update();
            }
            return true;
        }
        return false;
    }

    public function edit($name, $params = array(), $dir = '') {
        if ($original_page = $this->page->getCloneOriginal()) {
            return $original_page->getMediapool()->put($name, $params, $dir);
        }
        $dir = $this->getDir($dir);
        $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->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)) {
            foreach ($matches[0] as $match) {
                $new_url = preg_replace('/([&?])pool='.preg_quote($name, '/').'/msi', '$1pool='.$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
                            )
                        ) {
                            $list[] = $data;
                        }
                    }
                }
            }
        }
        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 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 (preg_match('/^\d+($|' . preg_quote(DIRECTORY_SEPARATOR, '/') . '.*?$)/', $dir)) {
            // 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 ($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);
                    return Ego_System::copy($source, $dest);
                }
            } 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);
                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) {
        $path = $this->dir();
        if (!empty($dir)) {
            $path .= rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
        }
        if (Ego_System::file_exists($path)) {
            // Original kopieren
            $dest = $this->dir(false, $target);
            if (!empty($dir)) {
                $dest .= rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
            }
            if (!$integrate) {
                Ego_System::deldir($dest);
            }
            Ego_System::copy($path, $dest, ($archive ? '' : '/^\d+$/'), true); // Hard Links erstellen

            // Verweise anpassen
            $target->getMediapool()->import(true, true, $dir, true, $asis);

            // Original löschen
            if ($clear) {
                $this->clear($dir);
            }
        }
    }

    public function move($target, $dir = '', $integrate = false, $archive = true) {
        $this->copy($target, $dir, true, $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 ($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);

        if ($update) { // 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)]);
            }
            $this->page->update(array(), true, true);
        }

        Ego_System::deldir($path);
    }

    public function import($only_pool = false, $replace = false, $dir = '', $update = true, $asis = true) {
        $this->page->field['content'] = $this->importRecursive($this->page->field['content'], $only_pool, $replace, $dir);
        $this->page->field['short'] = $this->importRecursive($this->page->field['short'], $only_pool, $replace, $dir);
        $this->page->extra = $this->importRecursive($this->page->extra, $only_pool, $replace, $dir);
        if ($update) {
            $this->page->update(array(
                'field' => array(
                    'content' => $this->page->field['content'],
                    'short' => $this->page->field['short']
                ),
                'extra' => $this->page->extra
            ), true, $asis);
        }
    }

    private function importRecursive($value, $only_pool = false, $replace = false, $dir = '') {
        if (is_array($value)) {
            foreach ($value as $key => $v) {
                $value[$key] = $this->importRecursive($v, $only_pool, $replace, $dir);
            }
        } 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, $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'],
                                $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'], $value);
                        }
                    }
                }
            }
        }
        return $value;
    }
}