FlySystemFileAccess.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Filesystem\Provider\FlySystem;
 
use ILIAS\Data\DataSize;
use ILIAS\Filesystem\Exception\FileAlreadyExistsException;
use ILIAS\Filesystem\Exception\FileNotFoundException;
use ILIAS\Filesystem\Exception\IOException;
use ILIAS\Filesystem\Provider\FileAccess;
use ILIAS\Filesystem\Visibility;
use League\Flysystem\FilesystemException;
use League\Flysystem\FilesystemOperator;
use League\Flysystem\UnableToRetrieveMetadata;
use League\Flysystem\UnableToDeleteFile;
use League\Flysystem\UnableToWriteFile;
use League\Flysystem\UnableToMoveFile;
use League\Flysystem\UnableToCopyFile;
 
class FlySystemFileAccess implements FileAccess
{
    public function __construct(
        private FilesystemOperator $flysystem_operator
    ) {
    }
 
    public function read(string $path): string
    {
        try {
            $path = Util::normalizeRelativePath($path);
            if (!$this->flysystem_operator->has($path)) {
                throw new \League\Flysystem\FileNotFoundException($path);
            }
            $result = $this->flysystem_operator->read($path);
 
            if (empty($result)) {
                throw new IOException("Could not access the file \"$path\".");
            }
 
            return $result;
        } catch (\Throwable $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
    public function has(string $path): bool
    {
        return $this->flysystem_operator->has($path);
    }
 
    public function getMimeType(string $path): string
    {
        try {
            $mimeType = $this->flysystem_operator->mimeType($path);
            if ($mimeType === '') {
                throw new IOException("Could not determine the MIME type of the file \"$path\".");
            }
 
            return $mimeType;
        } catch (UnableToRetrieveMetadata $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
    public function getTimestamp(string $path): \DateTimeImmutable
    {
        try {
            $last_modified = (int) $this->flysystem_operator->lastModified($path);
 
            return new \DateTimeImmutable(date('Y-m-d H:i:s', $last_modified));
        } catch (UnableToRetrieveMetadata) {
            throw new IOException("Could not lookup timestamp of the file \"$path\".");
        } catch (FilesystemException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
    public function getSize(string $path, int $unit): DataSize
    {
        try {
            $byte_size = $this->flysystem_operator->fileSize($path);
            return new DataSize($byte_size, $unit);
        } catch (UnableToRetrieveMetadata) {
            throw new FileNotFoundException("File \"$path\" not found.");
        }
    }
 
    public function setVisibility(string $path, string $visibility): bool
    {
        if (!$this->has($path)) {
            throw new FileNotFoundException("Path \"$path\" not found.");
        }
 
        $this->validateVisibility($visibility);
 
        try {
            $this->flysystem_operator->setVisibility($path, $visibility);
        } catch (\Throwable) {
            return false;
        }
        return true;
    }
 
    private function validateVisibility(string $visibility): void
    {
        if (strcmp($visibility, Visibility::PUBLIC_ACCESS) === 0) {
            return;
        }
        if (strcmp($visibility, Visibility::PRIVATE_ACCESS) === 0) {
            return;
        }
        throw new \InvalidArgumentException("The access must be 'public' or 'private' but '$visibility' was given.");
    }
 
    public function getVisibility(string $path): string
    {
        if (!$this->has($path)) {
            throw new FileNotFoundException("Path \"$path\" not found.");
        }
 
        $visibility = $this->flysystem_operator->getVisibility($path);
 
        if ($visibility === false) {
            throw new IOException("Could not determine visibility for path '$path'.");
        }
 
        return $visibility;
    }
 
    public function write(string $path, string $content): void
    {
        if ($this->flysystem_operator->has($path)) {
            throw new FileAlreadyExistsException("File \"$path\" already exists.");
        }
        try {
            $this->flysystem_operator->write($path, $content);
        } catch (FilesystemException) {
            throw new IOException(
                "Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable."
            );
        }
    }
 
    public function update(string $path, string $new_content): void
    {
        try {
            $this->flysystem_operator->write($path, $new_content);
        } catch (UnableToWriteFile $ex) {
            throw new IOException(
                "Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable.",
                0,
                $ex
            );
        } catch (UnableToRetrieveMetadata $ex) {
            throw new FileNotFoundException("File \"$path\" was not found update failed.", 0, $ex);
        }
    }
 
    public function put(string $path, string $content): void
    {
        if ($this->flysystem_operator->has($path)) {
            $this->update($path, $content);
            return;
        }
        $this->write($path, $content);
    }
 
    public function delete(string $path): void
    {
        try {
            $this->flysystem_operator->delete($path);
        } catch (UnableToRetrieveMetadata) {
            throw new FileNotFoundException("File \"$path\" was not found delete operation failed.");
        } catch (UnableToDeleteFile) {
            throw new IOException(
                "Could not delete file \"$path\" because a general IO error occurred. Please check that your target is writable."
            );
        }
    }
 
    public function readAndDelete(string $path): string
    {
        $content = $this->read($path);
        $this->delete($path);
 
        return $content;
    }
 
    public function rename(string $path, string $new_path): void
    {
        if ($this->flysystem_operator->has($new_path)) {
            throw new IOException("File \"$new_path\" already exists.");
        }
        try {
            $this->flysystem_operator->move($path, $new_path);
        } catch (UnableToMoveFile) {
            throw new IOException("Could not move file from \"$path\" to \"$new_path\".");
        } catch (UnableToRetrieveMetadata) {
            throw new FileNotFoundException("File \"$path\" not found.");
        }
    }
 
    public function copy(string $path, string $copy_path): void
    {
        if ($this->flysystem_operator->has($copy_path)) {
            throw new FileAlreadyExistsException("File \"$copy_path\" already exists.");
        }
        try {
            $this->flysystem_operator->copy($path, $copy_path);
        } catch (UnableToCopyFile) {
            throw new IOException(
                "Could not copy file \"$path\" to destination \"$copy_path\" because a general IO error occurred. Please check that your destination is writable."
            );
        } catch (UnableToRetrieveMetadata) {
            throw new FileNotFoundException("File source \"$path\" was not found copy failed.");
        }
    }
}