FlySystemDirectoryAccess.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Filesystem\Provider\FlySystem;
 
use ILIAS\Filesystem\DTO\Metadata;
use ILIAS\Filesystem\Exception\DirectoryNotFoundException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\Provider\DirectoryAccess;
use ILIAS\Filesystem\Visibility;
use League\Flysystem\CorruptedPathDetected;
use League\Flysystem\FilesystemOperator;
use League\Flysystem\UnableToRetrieveMetadata;
use League\Flysystem\UnableToCreateDirectory;
use League\Flysystem\StorageAttributes;
 
class FlySystemDirectoryAccess implements DirectoryAccess
{
    private const KEY_TYPE = 'type';
    private const KEY_PATH = 'path';
 
    public function __construct(
        private FilesystemOperator $flysystem_operator,
        private FlySystemFileAccess $flysystem_access
    ) {
    }
 
    public function hasDir(string $path): bool
    {
        try {
            return $this->flysystem_operator->directoryExists($path);
        } catch (CorruptedPathDetected) {
            // Paths containing funky whitespace (e.g. a tab or a line break) are rejected
            // by the path normalizer. Such a path can never be a usable directory, but it
            // must not abort the caller either, since these paths do occur on disk.
            return false;
        }
    }
 
    public function listContents(string $path = '', bool $recursive = false): array
    {
        if ($path !== '') {
            $this->ensureDirectoryExistence($path);
        }
 
        $contents = $this->flysystem_operator->listContents($path, $recursive);
        $metadata_collection = [];
 
        foreach ($contents as $content) {
            $metadata_collection[] = $this->attributesToMetadata($content);
        }
 
        return $metadata_collection;
    }
 
    public function createDir(string $path, string $visibility = Visibility::PUBLIC_ACCESS): void
    {
        $this->validateVisibility($visibility);
 
        $config = ['visibility' => $visibility];
        try {
            $this->flysystem_operator->createDirectory($path, $config);
        } catch (UnableToCreateDirectory) {
            throw new IOException("Could not create directory \"$path\"");
        }
    }
 
    public function copyDir(string $source, string $destination): void
    {
        $this->ensureDirectoryExistence($source);
        $this->ensureEmptyDirectory($destination);
 
        $content_list = $this->listContents($source, true);
 
        //foreach file and dir
        foreach ($content_list as $content) {
            //ignore the directories and only copy the files
            if ($content->isFile()) {
                //create destination path
                $position = strpos($content->getPath(), $source);
                if ($position !== false) {
                    $destinationFilePath = substr_replace(
                        $content->getPath(),
                        $destination,
                        $position,
                        strlen($source)
                    );
                    $this->flysystem_access->copy($content->getPath(), $destinationFilePath);
                }
            }
        }
    }
 
    private function ensureEmptyDirectory(string $path): void
    {
        // check if destination dir is empty
        try {
            $destination_content = $this->listContents($path, true);
            if ($destination_content !== []) {
                throw new IOException("Destination \"$path\" is not empty can not copy files.");
            }
        } catch (UnableToRetrieveMetadata) {
            //nothing needs to be done the destination was not found
        }
    }
 
    private function ensureDirectoryExistence(string $path): void
    {
        if (!$this->hasDir($path)) {
            throw new DirectoryNotFoundException("Directory \"$path\" not found.");
        }
    }
 
    public function deleteDir(string $path): void
    {
        try {
            $this->flysystem_operator->deleteDirectory($path);
        } catch (UnableToRetrieveMetadata) {
            throw new IOException("Could not find directory \"$path\".");
        } catch (UnableToDeleteDirectory|\Throwable) {
            throw new IOException("Could not delete directory \"$path\".");
        }
        if ($this->flysystem_operator->has($path)) {
            throw new IOException("Could not find directory \"$path\".");
        }
    }
 
    private function attributesToMetadata(StorageAttributes $attributes): Metadata
    {
        return new Metadata(
            $attributes->path(),
            $attributes->type()
        );
    }
 
    private function validateVisibility(string $visibility): void
    {
        if (strcmp($visibility, Visibility::PRIVATE_ACCESS) === 0) {
            return;
        }
        if (strcmp($visibility, Visibility::PUBLIC_ACCESS) === 0) {
            return;
        }
        throw new \InvalidArgumentException("Invalid visibility expected public or private but got \"$visibility\".");
    }
}