FlySystemDirectoryAccess.php

Go to the documentation of this file.

<?php

namespace ILIAS\Filesystem\Provider\FlySystem;

;

use ILIAS\Filesystem\DTO\Metadata;
use ILIAS\Filesystem\Exception\DirectoryNotFoundException;
use ILIAS\Filesystem\Exception\FileNotFoundException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\MetadataType;
use ILIAS\Filesystem\Provider\DirectoryAccess;
use ILIAS\Filesystem\Visibility;
use League\Flysystem\FilesystemInterface;
use League\Flysystem\RootViolationException;

class FlySystemDirectoryAccess implements DirectoryAccess
{

    private $flySystemFS;
    private $fileAccess;
    private static $metaTypeKey = 'type';
    private static $metaPathKey = 'path';


    public function __construct(FilesystemInterface $flySystemFS, FlySystemFileAccess $fileAccess)
    {
        $this->flySystemFS = $flySystemFS;
        $this->fileAccess = $fileAccess;
    }


    public function hasDir($path)
    {
        if ($this->flySystemFS->has($path)) {
            $meta = $this->flySystemFS->getMetadata($path);

            if (!(is_array($meta) && array_key_exists(self::$metaTypeKey, $meta))) {
                throw new IOException("Could not evaluate path type: \"$path\"");
            }

            return strcmp($meta[self::$metaTypeKey], MetadataType::DIRECTORY) === 0;
        }

        return false;
    }


    public function listContents($path = '', $recursive = false)
    {
        if ($path !== '') {
            $this->ensureDirectoryExistence($path);
        }

        $contents = $this->flySystemFS->listContents($path, $recursive);
        $metadataCollection = [];

        foreach ($contents as $content) {
            if (!(array_key_exists(self::$metaTypeKey, $content) && array_key_exists(self::$metaPathKey, $content))) {
                throw new IOException("Invalid metadata received for path \"$path\"");
            }

            $metadataCollection[] = $this->arrayToMetadata($content);
        }
        
        return $metadataCollection;
    }


    public function createDir($path, $visibility = Visibility::PUBLIC_ACCESS)
    {
        $this->validateVisibility($visibility);

        $config = ['visibility' => $visibility];
        $successful = $this->flySystemFS->createDir($path, $config);

        if (!$successful) {
            throw new IOException("Could not create directory \"$path\"");
        }
    }


    public function copyDir($source, $destination)
    {
        $this->ensureDirectoryExistence($source);
        $this->ensureEmptyDirectory($destination);

        $contentList = $this->listContents($source, true);

        //foreach file and dir
        foreach ($contentList 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->fileAccess->copy($content->getPath(), $destinationFilePath);
                }
            }
        }
    }


    private function ensureEmptyDirectory($path)
    {

        //check if destination dir is empty
        try {
            $destinationContent = $this->listContents($path, true);
            if (count($destinationContent) !== 0) {
                throw new IOException("Destination \"$path\" is not empty can not copy files.");
            }
        } catch (DirectoryNotFoundException $ex) {
            //nothing needs to be done the destination was not found
        }
    }


    private function ensureDirectoryExistence($path)
    {
        if (!$this->hasDir($path)) {
            throw new DirectoryNotFoundException("Directory \"$path\" not found.");
        }
    }


    public function deleteDir($path)
    {
        try {
            if ($this->flySystemFS->deleteDir($path) === false) {
                throw new IOException("Could not delete directory \"$path\".");
            }
        } catch (RootViolationException $ex) {
            throw new IOException('The filesystem root must not be deleted.', 0, $ex);
        }
    }


    private function arrayToMetadata(array $metadataArray)
    {
        return new Metadata(
            $metadataArray[self::$metaPathKey],
            $metadataArray[self::$metaTypeKey]
        );
    }


    private function validateVisibility($visibility)
    {
        if (strcmp($visibility, Visibility::PRIVATE_ACCESS) !== 0 && strcmp($visibility, Visibility::PUBLIC_ACCESS) !== 0) {
            throw new \InvalidArgumentException("Invalid visibility expected public or private but got \"$visibility\".");
        }
    }
}