ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess Class Reference

Fly system file access implementation. More...

Inheritance diagram for ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess:

Collaboration diagram for ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess:

Public Member Functions
	__construct (private FilesystemOperator $flysystem_operator)
	read (string $path)
	Reads a file content to a string. More...
	has (string $path)
	Checks whether a file exists. More...
	getMimeType (string $path)
	Get a files mime-type. More...
	getTimestamp (string $path)
	Get the timestamp of the file. More...
	getSize (string $path, int $unit)
	Get the size of a file. More...
	setVisibility (string $path, string $visibility)
	Sets the visibility for a file. More...
	getVisibility (string $path)
	Get the file visibility. More...
	write (string $path, string $content)
	Writes the content to a new file. More...
	update (string $path, string $new_content)
	Updates the content of a file. More...
	put (string $path, string $content)
	Creates a file or updates an existing one. More...
	delete (string $path)
	Deletes a file. More...
	readAndDelete (string $path)
	Reads the entire file content into a string and removes the file afterwards. More...
	rename (string $path, string $new_path)
	Moves a file from the source to the destination. More...
	copy (string $path, string $copy_path)
	Copy the source file to a destination. More...

Private Member Functions
	validateVisibility (string $visibility)
	Checks if the given visibility is valid an throws an exception otherwise. More...

Detailed Description

Fly system file access implementation.

Author

Nicolas Schäfli ns@st.nosp@m.uder.nosp@m.-raim.nosp@m.ann..nosp@m.ch

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 43 of file FlySystemFileAccess.php.

Constructor & Destructor Documentation

__construct()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::__construct

(

private FilesystemOperator

$flysystem_operator

)

Definition at line 45 of file FlySystemFileAccess.php.

      {
    }

Member Function Documentation

copy()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::copy	(	string	$path,
		string	$copy_path
	)

Copy the source file to a destination.

Parameters

string	$path	The source path to the file which should be copied.
string	$copy_path	The destination path of the file copy.

Exceptions

FileNotFoundException	If the source file does not exist.
FileAlreadyExistsException	If the destination file already exists.
IOException	If the file could not be copied to the destination.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 333 of file FlySystemFileAccess.php.

                                                         : 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.");
        }
    }

delete()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::delete

(

string

$path

)

Deletes a file.

Parameters

string

$path

The path to the file which should be deleted.

Exceptions

FileNotFoundException	If the file was not found.
IOException	If the file was found but the delete operation finished with errors.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 264 of file FlySystemFileAccess.php.

References $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."
            );
        }
    }

getMimeType()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::getMimeType

(

string

$path

)

Get a files mime-type.

Parameters

string

$path

The file which should be used to get the mime-type.

Returns

string The mime-type of the file.

Exceptions

FileNotFoundException	If the file is not found.
IOException	If the mime-type could not be determined.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 74 of file FlySystemFileAccess.php.

                                             : 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);
        }
    }

getSize()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::getSize	(	string	$path,
		int	$unit
	)

Get the size of a file.

The file size units are provided by the DataSize class.

Parameters

string	$path	The path to the file.
int	$unit	The unit of the file size, which are defined in the DataSize class.

Exceptions

IOException	Thrown if the file is not accessible or the underlying filesystem adapter failed.
FileNotFoundException	Thrown if the specified file was not found.

See also

DataSize

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 101 of file FlySystemFileAccess.php.

                                                    : DataSize
    {
        try {
            $byte_size = $this->flysystem_operator->fileSize($path);
            return new DataSize($byte_size, $unit);
        } catch (UnableToRetrieveMetadata) {
            throw new FileNotFoundException("File \"$path\" not found.");
        }
    }

getTimestamp()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::getTimestamp

(

string

$path

)

Get the timestamp of the file.

Parameters

string

$path

The path to the file.

Returns

The timestamp of the file.

Exceptions

FileNotFoundException	If the file is not found.
IOException	If the file can not be red.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 88 of file FlySystemFileAccess.php.

References ILIAS\Repository\int().

                                              : \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);
        }
    }

Here is the call graph for this function:

getVisibility()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::getVisibility

(

string

$path

)

Get the file visibility.

The file visibility could be 'public' or 'private'.

Please note that the Visibility interface defines two constants PUBLIC_ACCESS and PRIVATE_ACCESS to ease the development process.

Parameters

string

$path

The path to the file which should be used.

Returns

string The string 'public' or 'private'.

Exceptions

FileNotFoundException	If the file could not be found.
IOException	If the underlying adapter failed to determine the visibility.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 168 of file FlySystemFileAccess.php.

References ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\has().

                                               : 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;
    }

Here is the call graph for this function:

has()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::has

(

string

$path

)

Checks whether a file exists.

Parameters

string

$path

The file path which should be checked.

Returns

bool True if the file exists, otherwise false.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 69 of file FlySystemFileAccess.php.

Referenced by ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\getVisibility(), and ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\setVisibility().

                                     : bool
    {
        return $this->flysystem_operator->has($path);
    }

Here is the caller graph for this function:

put()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::put	(	string	$path,
		string	$content
	)

Creates a file or updates an existing one.

Parameters

string	$path	The path to the file which should be created or updated.
string	$content	The content which should be written to the file.

Exceptions

IOException

If the file could not be created or updated.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 245 of file FlySystemFileAccess.php.

References ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\update(), and ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\write().

                                                      : void
    {
        if ($this->flysystem_operator->has($path)) {
            $this->update($path, $content);
            return;
        }
        $this->write($path, $content);
    }

Here is the call graph for this function:

read()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::read

(

string

$path

)

Reads a file content to a string.

Parameters

string

$path

The path to the file which should be read.

Returns

string The file content.

Exceptions

FileNotFoundException	If the file doesn't exist.
IOException	If the file could not be red.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 50 of file FlySystemFileAccess.php.

References ILIAS\Filesystem\Provider\FlySystem\Util\normalizeRelativePath().

Referenced by ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\readAndDelete().

                                      : 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);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

readAndDelete()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::readAndDelete

(

string

$path

)

Reads the entire file content into a string and removes the file afterwards.

Parameters

string

$path

The file which should be red and removed.

Returns

string The entire file content.

Exceptions

FileNotFoundException	If the file was not found.
IOException	If the file could not red or deleted.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 288 of file FlySystemFileAccess.php.

References $path, and ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\read().

                                               : string
    {
        $content = $this->read($path);
        $this->delete($path);

        return $content;
    }

Here is the call graph for this function:

rename()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::rename	(	string	$path,
		string	$new_path
	)

Moves a file from the source to the destination.

Parameters

string	$path	The current path of the file which should be moved.
string	$new_path	The new path of the file.

Exceptions

FileNotFoundException	If the source file is not found.
FileAlreadyExistsException	If the destination file is already existing.
IOException	If the file could not be moved.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 308 of file FlySystemFileAccess.php.

                                                          : 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.");
        }
    }

setVisibility()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::setVisibility	(	string	$path,
		string	$visibility
	)

Sets the visibility for a file.

Please note that the $visibility must 'public' or 'private'.

The Visibility interface provides two constants PUBLIC_ACCESS and PRIVATE_ACCESS. We strongly encourage the consumers of this API to use the constants.

Implements ILIAS\Filesystem\Provider\FileReadAccess.

Definition at line 118 of file FlySystemFileAccess.php.

References ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\has(), and ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\validateVisibility().

                                                                   : 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;
    }

Here is the call graph for this function:

update()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::update	(	string	$path,
		string	$new_content
	)

Updates the content of a file.

Replaces the file content with a new one.

Parameters

string	$path	The path to the file which should be updated.
string	$new_content	The new file content.

Exceptions

FileNotFoundException	If the file is not found.
IOException	If the file could not be updated.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 220 of file FlySystemFileAccess.php.

Referenced by ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\put().

                                                             : 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);
        }
    }

Here is the caller graph for this function:

validateVisibility()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::validateVisibility ( string  $visibility )

private

Checks if the given visibility is valid an throws an exception otherwise.

If the visibility is valid no further actions are taken.

Parameters

string

$visibility

The visibility which should be validated.

Exceptions

Definition at line 142 of file FlySystemFileAccess.php.

References ILIAS\Filesystem\Visibility\PRIVATE_ACCESS, and ILIAS\Filesystem\Visibility\PUBLIC_ACCESS.

Referenced by ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\setVisibility().

                                                           : 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.");
    }

Here is the caller graph for this function:

write()

ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess::write	(	string	$path,
		string	$content
	)

Writes the content to a new file.

Parameters

string	$path	The path to the file which should be created.
string	$content	The content which should be written to the new file.

Exceptions

FileAlreadyExistsException	If the file already exists.
IOException	If the file could not be created or written.

Implements ILIAS\Filesystem\Provider\FileWriteAccess.

Definition at line 194 of file FlySystemFileAccess.php.

Referenced by ILIAS\Filesystem\Provider\FlySystem\FlySystemFileAccess\put().

                                                        : 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."
            );
        }
    }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• components/ILIAS/Filesystem/src/Provider/FlySystem/FlySystemFileAccess.php