AbstractFile.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Resource;
 
use ‪TYPO3\CMS\Core\Resource\Enum\DuplicationBehavior;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
abstract class ‪AbstractFile implements ‪FileInterface
{
    protected array ‪$properties = [];
 
    protected ‪$storage;
 
    protected ‪$identifier;
 
    protected ‪$name;
 
    protected ‪$deleted = false;
 
    public const ‪FILETYPE_UNKNOWN = 0;
 
    public const ‪FILETYPE_TEXT = 1;
 
    public const ‪FILETYPE_IMAGE = 2;
 
    public const ‪FILETYPE_AUDIO = 3;
 
    public const ‪FILETYPE_VIDEO = 4;
 
    public const ‪FILETYPE_APPLICATION = 5;
 
    /******************
     * VARIOUS FILE PROPERTY GETTERS
     ******************/
    public function ‪hasProperty(string $key): bool
    {
        return array_key_exists($key, $this->‪properties);
    }
 
    public function ‪getProperty(string $key): mixed
    {
        if ($this->‪hasProperty($key)) {
            return $this->‪properties[$key];
        }
        return null;
    }
 
    public function getProperties()
    {
        return ‪$this->properties;
    }
 
    public function ‪getIdentifier(): string
    {
        return ‪$this->identifier;
    }
 
    public function ‪getHashedIdentifier(): string
    {
        return $this->‪properties['identifier_hash'];
    }
 
    public function ‪getName(): string
    {
        // Do not check if file has been deleted because we might need the
        // name for undeleting it.
        return ‪$this->name;
    }
 
    public function ‪getNameWithoutExtension(): string
    {
        return ‪PathUtility::pathinfo($this->‪getName(), PATHINFO_FILENAME);
    }
 
    public function getSize(): int
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821480);
        }
        if (empty($this->‪properties['size'])) {
            $fileInfo = $this->‪getStorage()->getFileInfoByIdentifier($this->‪getIdentifier(), ['size']);
            ‪$size = array_pop($fileInfo);
        } else {
            ‪$size = $this->‪properties['size'];
        }
        return ‪MathUtility::canBeInterpretedAsInteger(‪$size) ? (int)‪$size : 0;
    }
 
    public function ‪getUid()
    {
        return (int)$this->‪getProperty('uid');
    }
 
    public function ‪getSha1(): string
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821481);
        }
        return $this->‪getStorage()->hashFile($this, 'sha1');
    }
 
    public function ‪getCreationTime(): int
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821487);
        }
        return (int)$this->‪getProperty('creation_date');
    }
 
    public function ‪getModificationTime(): int
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821488);
        }
        return (int)$this->‪getProperty('modification_date');
    }
 
    public function ‪getExtension(): string
    {
        $pathinfo = ‪PathUtility::pathinfo($this->‪getName());
 
        $extension = strtolower($pathinfo['extension'] ?? '');
 
        return $extension;
    }
 
    public function ‪getMimeType(): string
    {
        if ($this->‪properties['mime_type'] ?? false) {
            return $this->‪properties['mime_type'];
        }
        $fileInfo = $this->‪getStorage()->getFileInfoByIdentifier($this->‪getIdentifier(), ['mimetype']);
        return array_pop($fileInfo);
    }
 
    #[\ReturnTypeWillChange]
    public function ‪getType()
    {
        // this basically extracts the mimetype and guess the filetype based
        // on the first part of the mimetype works for 99% of all cases, and
        // we don't need to make an SQL statement like EXT:media does currently
        if (!($this->‪properties['type'] ?? false)) {
            $this->‪properties['type'] = ‪FileType::tryFromMimeType($this->‪getMimeType())->value;
        }
        return (int)$this->‪properties['type'];
    }
 
    public function ‪isType(‪FileType $fileType): bool
    {
        return FileType::tryFrom($this->‪getType()) === $fileType;
    }
 
    public function ‪isImage(): bool
    {
        return ‪GeneralUtility::inList(strtolower(‪$GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'] ?? ''), $this->‪getExtension()) && $this->getSize() > 0;
    }
 
    public function ‪isMediaFile(): bool
    {
        return ‪GeneralUtility::inList(strtolower(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['mediafile_ext'] ?? ''), $this->‪getExtension()) && $this->getSize() > 0;
    }
 
    public function ‪isTextFile(): bool
    {
        return ‪GeneralUtility::inList(strtolower(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['textfile_ext'] ?? ''), $this->‪getExtension());
    }
    /******************
     * CONTENTS RELATED
     ******************/
    public function ‪getContents(): string
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821479);
        }
        return $this->‪getStorage()->getFileContents($this);
    }
 
    public function ‪setContents(string $contents): self
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821478);
        }
        $this->‪getStorage()->setFileContents($this, $contents);
        return $this;
    }
 
    /****************************************
     * STORAGE AND MANAGEMENT RELATED METHODS
     ****************************************/
 
    public function ‪getStorage(): ‪ResourceStorage
    {
        if ($this->storage === null) {
            throw new \RuntimeException('You\'re using fileObjects without a storage.', 1381570091);
        }
        return ‪$this->storage;
    }
 
    public function ‪exists()
    {
        if ($this->deleted) {
            return false;
        }
        return $this->storage->hasFile($this->‪getIdentifier());
    }
 
    public function ‪setStorage(ResourceStorage ‪$storage)
    {
        $this->storage = ‪$storage;
        $this->‪properties['storage'] = $storage->getUid();
        return $this;
    }
 
    public function ‪setIdentifier(‪$identifier)
    {
        $this->identifier = ‪$identifier;
        return $this;
    }
 
    public function ‪getCombinedIdentifier()
    {
        if (!empty($this->‪properties['storage']) && ‪MathUtility::canBeInterpretedAsInteger($this->‪properties['storage'])) {
            $combinedIdentifier = $this->‪properties['storage'] . ':' . $this->‪getIdentifier();
        } else {
            $combinedIdentifier = $this->‪getStorage()->‪getUid() . ':' . $this->‪getIdentifier();
        }
        return $combinedIdentifier;
    }
 
    public function delete(): bool
    {
        // The storage will mark this file as deleted
        $wasDeleted = $this->‪getStorage()->deleteFile($this);
 
        // Unset all properties when deleting the file, as they will be stale anyway
        // This needs to happen AFTER the storage deleted the file, because the storage
        // emits a signal, which passes the file object to the slots, which may need
        // all file properties of the deleted file.
        $this->‪properties = [];
 
        return $wasDeleted;
    }
 
    public function ‪setDeleted()
    {
        $this->deleted = true;
    }
 
    public function ‪isDeleted()
    {
        return ‪$this->deleted;
    }
 
    public function ‪rename(string $newName, $conflictMode = ‪DuplicationBehavior::RENAME): FileInterface
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821482);
        }
 
        if (!$conflictMode instanceof ‪DuplicationBehavior) {
            trigger_error(
                'Using a string of the non-native enumeration TYPO3\CMS\Core\Resource\DuplicationBehavior in AbstractFile->rename()'
                . ' will stop working in TYPO3 v14.0. Use native TYPO3\CMS\Core\Resource\Enum\DuplicationBehavior instead.',
                E_USER_DEPRECATED
            );
            $conflictMode = DuplicationBehavior::tryFrom($conflictMode) ?? ‪DuplicationBehavior::getDefaultDuplicationBehaviour();
        }
 
        return $this->‪getStorage()->renameFile($this, $newName, $conflictMode);
    }
 
    public function ‪copyTo(Folder $targetFolder, $targetFileName = null, $conflictMode = ‪DuplicationBehavior::RENAME)
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821483);
        }
 
        if (!$conflictMode instanceof ‪DuplicationBehavior) {
            trigger_error(
                'Using a string of the non-native enumeration TYPO3\CMS\Core\Resource\DuplicationBehavior in AbstractFile->copyTo()'
                . ' will stop working in TYPO3 v14.0. Use native TYPO3\CMS\Core\Resource\Enum\DuplicationBehavior instead.',
                E_USER_DEPRECATED
            );
            $conflictMode = DuplicationBehavior::tryFrom($conflictMode) ?? ‪DuplicationBehavior::getDefaultDuplicationBehaviour();
        }
 
        return $targetFolder->getStorage()->copyFile($this, $targetFolder, $targetFileName, $conflictMode);
    }
 
    public function ‪moveTo(Folder $targetFolder, $targetFileName = null, $conflictMode = ‪DuplicationBehavior::RENAME)
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821484);
        }
 
        if (!$conflictMode instanceof ‪DuplicationBehavior) {
            trigger_error(
                'Using a string of the non-native enumeration TYPO3\CMS\Core\Resource\DuplicationBehavior in AbstractFile->moveTo()'
                . ' will stop working in TYPO3 v14.0. Use native TYPO3\CMS\Core\Resource\Enum\DuplicationBehavior instead.',
                E_USER_DEPRECATED
            );
            $conflictMode = DuplicationBehavior::tryFrom($conflictMode) ?? ‪DuplicationBehavior::getDefaultDuplicationBehaviour();
        }
 
        return $targetFolder->getStorage()->moveFile($this, $targetFolder, $targetFileName, $conflictMode);
    }
 
    /*****************
     * SPECIAL METHODS
     *****************/
    public function ‪getPublicUrl(): ?string
    {
        if ($this->deleted) {
            return null;
        }
        return $this->‪getStorage()->‪getPublicUrl($this);
    }
 
    public function ‪getForLocalProcessing(bool $writable = true): string
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821486);
        }
        return $this->‪getStorage()->getFileForLocalProcessing($this, $writable);
    }
 
    /***********************
     * INDEX RELATED METHODS
     ***********************/
    abstract public function ‪updateProperties(array ‪$properties);
 
    public function ‪getParentFolder(): FolderInterface
    {
        return $this->‪getStorage()->getFolder($this->‪getStorage()->getFolderIdentifierFromFileIdentifier($this->‪getIdentifier()));
    }
}