class.ilFileSystemAbstractionStorage.php

Go to the documentation of this file.

<?php

use ILIAS\Filesystem\Filesystems;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\Util\LegacyPathHelper;
use ILIAS\Filesystem\Filesystem;

abstract class ilFileSystemAbstractionStorage
{
    public const STORAGE_WEB = 1;
    public const STORAGE_DATA = 2;
    public const STORAGE_SECURED = 3;
    private const FACTOR = 100;
    private const MAX_EXPONENT = 3;
    private const SECURED_DIRECTORY = "sec";
    protected ?string $path = null;
    protected Filesystems $file_system_service;

    public function __construct(private int $storage_type, private bool $path_conversion, private int $container_id)
    {
        global $DIC;
        $this->file_system_service = $DIC->filesystem();

        // Get path info
        $this->init();
    }

    public function fileExists(string $a_absolute_path): bool
    {
        return $this->getFileSystemService()->has($this->createRelativePathForFileSystem($a_absolute_path));
    }

    protected function getLegacyFullAbsolutePath(string $relative_path): string
    {
        $stream = $this->getFileSystemService()->readStream($relative_path);

        return $stream->getMetadata('uri');
    }

    protected function getFileSystemService(): Filesystem
    {
        switch ($this->getStorageType()) {
            case self::STORAGE_DATA:
                return $this->file_system_service->storage();
            case self::STORAGE_WEB:
            case self::STORAGE_SECURED:
            case self::SECURED_DIRECTORY:
                return $this->file_system_service->web();
        }
        throw new LogicException('cannot determine correct filesystem');
    }

    public function getContainerId(): int
    {
        return $this->container_id;
    }

    public static function createPathFromId(int $a_container_id, string $a_name): string
    {
        $path = [];
        $found = false;
        $num = $a_container_id;
        $path_string = '';
        for ($i = self::MAX_EXPONENT; $i > 0; $i--) {
            $factor = self::FACTOR ** $i;
            if (($tmp = (int) ($num / $factor)) or $found) {
                $path[] = $tmp;
                $num %= $factor;
                $found = true;
            }
        }

        if ($path !== []) {
            $path_string = (implode('/', $path) . '/');
        }

        return $path_string . $a_name . '_' . $a_container_id;
    }

    public function writeToFile(string $a_data, $a_absolute_path)
    {
        if (!$fp = @fopen($a_absolute_path, 'w+')) {
            return false;
        }
        if (@fwrite($fp, $a_data) === false) {
            @fclose($fp);
            return false;
        }
        @fclose($fp);
        return true;
    }

    public function copyFile(string $a_from, string $a_to): bool
    {
        if (@file_exists($a_from)) {
            @copy($a_from, $a_to);
            return true;
        }
        return false;
    }

    abstract protected function getPathPrefix(): string;

    abstract protected function getPathPostfix(): string;

    public function create(): void
    {
        if (!$this->getFileSystemService()->has($this->path)) {
            $this->getFileSystemService()->createDir($this->path);
        }
    }

    public function getAbsolutePath(): string
    {
        return rtrim($this->getLegacyAbsolutePath(), "/");
    }

    protected function getLegacyAbsolutePath(): string
    {
        if (!$this->getFileSystemService()->has($this->path)) {
            $this->getFileSystemService()->createDir($this->path);
        }

        if ($this->getStorageType() === self::STORAGE_DATA) {
            return rtrim(CLIENT_DATA_DIR, '/') . '/' . ltrim((string) $this->path, '/');
        }
        return rtrim(CLIENT_WEB_DIR, '/') . '/' . ltrim((string) $this->path, '/');
    }

    protected function init(): bool
    {
        switch ($this->storage_type) {
            case self::STORAGE_DATA:
            case self::STORAGE_WEB:
                break;
            case self::STORAGE_SECURED:
                $this->path = rtrim($this->path ?? '', '/') . '/' . self::SECURED_DIRECTORY . '/';
                break;
        }

        // Append path prefix
        $this->path .= ($this->getPathPrefix() . '/');

        if ($this->path_conversion) {
            $this->path .= self::createPathFromId($this->container_id, $this->getPathPostfix());
        } else {
            $this->path .= ($this->getPathPostfix() . '_' . $this->container_id);
        }

        return true;
    }

    public function delete(): bool
    {
        try {
            $this->getFileSystemService()->deleteDir($this->getAbsolutePath());
        } catch (Exception) {
            return false;
        }

        return true;
    }

    public function deleteDirectory(string $a_abs_name): bool
    {
        $path = $this->createRelativePathForFileSystem($a_abs_name);
        $this->getFileSystemService()->deleteDir($path);
        return !$this->getFileSystemService()->has($path);
    }

    public function deleteFile(string $a_abs_name): bool
    {
        $path = $this->createRelativePathForFileSystem($a_abs_name);
        $this->getFileSystemService()->delete($path);
        return !$this->getFileSystemService()->has($path);
    }

    public static function _copyDirectory(string $a_sdir, string $a_tdir): bool
    {
        try {
            $sourceFS = LegacyPathHelper::deriveFilesystemFrom($a_sdir);
            $targetFS = LegacyPathHelper::deriveFilesystemFrom($a_tdir);

            $sourceDir = LegacyPathHelper::createRelativePath($a_sdir);
            $targetDir = LegacyPathHelper::createRelativePath($a_tdir);

            // check if arguments are directories
            if (!$sourceFS->hasDir($sourceDir)) {
                return false;
            }

            $sourceList = $sourceFS->listContents($sourceDir, true);

            foreach ($sourceList as $item) {
                if ($item->isDir()) {
                    continue;
                }

                $itemPath = $targetDir . '/' . substr($item->getPath(), strlen($sourceDir));
                $stream = $sourceFS->readStream($sourceDir);
                $targetFS->writeStream($itemPath, $stream);
            }

            return true;
        } catch (\Exception) {
            return false;
        }
    }

    public function appendToPath(string $a_appendix): void
    {
        $this->path .= $a_appendix;
    }

    public function getStorageType(): int
    {
        return $this->storage_type;
    }

    public function getPath(): string
    {
        return $this->path;
    }

    private function createRelativePathForFileSystem(string $a_absolute_path): string
    {
        $relative_path = LegacyPathHelper::createRelativePath($a_absolute_path);

        return $relative_path;
    }
}