FlySystemFileAccess.php

Go to the documentation of this file.

<?php
 
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\FileExistsException;
use League\Flysystem\FilesystemInterface;
 
class FlySystemFileAccess implements FileAccess
{
 
    private $flySystemFS;
 
 
    public function __construct(FilesystemInterface $flySystemFS)
    {
        $this->flySystemFS = $flySystemFS;
    }
 
 
    public function read($path)
    {
        $this->nonNull($path, 'path');
 
        try {
            $result = $this->flySystemFS->read($path);
 
            if ($result === false) {
                throw new IOException("Could not access the file \"$path\".");
            }
 
            return $result;
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
 
    public function has($path)
    {
        $this->nonNull($path, 'path');
 
        return $this->flySystemFS->has($path);
    }
 
 
    public function getMimeType($path)
    {
        $this->nonNull($path, 'path');
 
        try {
            $mimeType = $this->flySystemFS->getMimetype($path);
            if ($mimeType === false) {
                throw new IOException("Could not determine the MIME type of the file \"$path\".");
            }
 
            return $mimeType;
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
 
    public function getTimestamp($path)
    {
        $this->nonNull($path, 'path');
 
        try {
            $rawTimestamp = $this->flySystemFS->getTimestamp($path);
            if ($rawTimestamp === false) {
                throw new IOException("Could not lookup timestamp of the file \"$path\".");
            }
 
            return new \DateTime($rawTimestamp);
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.", 0, $ex);
        }
    }
 
 
    public function getSize($path, $fileSizeUnit)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($fileSizeUnit, 'fileSizeUnit');
 
        try {
            $byteSize = $this->flySystemFS->getSize($path);
 
            //check if the fly system adapter failed
            if ($byteSize === false) {
                throw new IOException("Could not calculate the file size of the file \"$path\".");
            }
 
            $size = new DataSize($byteSize, $fileSizeUnit);
            return  $size;
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.");
        }
    }
 
 
    public function setVisibility($path, $visibility)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($visibility, 'visibility');
 
        if ($this->has($path) === false) {
            throw new FileNotFoundException("Path \"$path\" not found.");
        }
 
        $this->validateVisibility($visibility);
 
        return $this->flySystemFS->setVisibility($path, $visibility);
    }
 
 
    private function validateVisibility($visibility)
    {
        if (strcmp($visibility, Visibility::PUBLIC_ACCESS) !== 0 && strcmp($visibility, Visibility::PRIVATE_ACCESS) !== 0) {
            throw new \InvalidArgumentException("The access must be 'public' or 'private' but '$visibility' was given.");
        }
    }
 
 
    public function getVisibility($path)
    {
        $this->nonNull($path, 'path');
 
        if ($this->has($path) === false) {
            throw new FileNotFoundException("Path \"$path\" not found.");
        }
 
        $visibility = $this->flySystemFS->getVisibility($path);
 
        if ($visibility === false) {
            throw new IOException("Could not determine visibility for path '$path'.");
        }
 
        return $visibility;
    }
 
 
    public function write($path, $content)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($content, 'content');
 
        try {
            if ($this->flySystemFS->write($path, $content) === false) {
                throw new IOException("Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable.");
            }
        } catch (FileExistsException $ex) {
            throw new FileAlreadyExistsException("File \"$path\" already exists.", 0, $ex);
        }
    }
 
 
    public function update($path, $newContent)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($newContent, 'newContent');
 
        try {
            if ($this->flySystemFS->update($path, $newContent) === false) {
                throw new IOException("Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable.");
            }
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" was not found update failed.", 0, $ex);
        }
    }
 
 
    public function put($path, $content)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($content, 'content');
 
        if ($this->flySystemFS->put($path, $content) === false) {
            throw new IOException("Could not write to file \"$path\" because a general IO error occurred. Please check that your destination is writable.");
        }
    }
 
 
    public function delete($path)
    {
        $this->nonNull($path, 'path');
 
        try {
            if ($this->flySystemFS->delete($path) === false) {
                throw new IOException("Could not delete file \"$path\" because a general IO error occurred. Please check that your target is writable.");
            }
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" was not found delete operation failed.");
        }
    }
 
 
    public function readAndDelete($path)
    {
        $this->nonNull($path, 'path');
 
        $content = $this->read($path);
        $this->delete($path);
 
        return $content;
    }
 
 
    public function rename($path, $newPath)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($newPath, 'newPath');
 
        try {
            if ($this->flySystemFS->rename($path, $newPath) === false) {
                throw new IOException("Could not move file from \"$path\" to \"$newPath\".");
            }
        } catch (FileExistsException $ex) {
            throw new FileAlreadyExistsException("File \"$newPath\" already exists.");
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File \"$path\" not found.");
        }
    }
 
 
    public function copy($path, $copyPath)
    {
        $this->nonNull($path, 'path');
        $this->nonNull($copyPath, 'copyPath');
 
        try {
            if ($this->flySystemFS->copy($path, $copyPath) === false) {
                throw new IOException("Could not copy file \"$path\" to destination \"$copyPath\" because a general IO error occurred. Please check that your destination is writable.");
            }
        } catch (FileExistsException $ex) {
            throw new FileAlreadyExistsException("File destination \"$copyPath\" already exists copy failed.");
        } catch (\League\Flysystem\FileNotFoundException $ex) {
            throw new FileNotFoundException("File source \"$path\" was not found copy failed.");
        }
    }
 
 
    private function nonNull($toCheck, $parameterName)
    {
        if (is_null($toCheck)) {
            throw new \InvalidArgumentException("The parameter \"$parameterName\" must not be null.");
        }
    }
}