AbstractFile.php

Go to the documentation of this file.

<?php
 
/*
 * 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\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
abstract class ‪AbstractFile implements ‪FileInterface
{
    protected ‪$properties;
 
    protected ‪$storage;
 
    protected ‪$identifier;
 
    protected ‪$name;
 
    protected ‪$deleted = false;
 
    const ‪FILETYPE_UNKNOWN = 0;
 
    const ‪FILETYPE_TEXT = 1;
 
    const ‪FILETYPE_IMAGE = 2;
 
    const ‪FILETYPE_AUDIO = 3;
 
    const ‪FILETYPE_VIDEO = 4;
 
    const ‪FILETYPE_APPLICATION = 5;
 
    /******************
     * VARIOUS FILE PROPERTY GETTERS
     ******************/
    public function ‪hasProperty($key)
    {
        return array_key_exists($key, $this->properties);
    }
 
    public function ‪getProperty($key)
    {
        if ($this->‪hasProperty($key)) {
            return $this->properties[$key];
        }
        return null;
    }
 
    public function ‪getProperties()
    {
        return ‪$this->properties;
    }
 
    public function ‪getIdentifier()
    {
        return ‪$this->identifier;
    }
 
    public function ‪getHashedIdentifier()
    {
        return $this->properties['identifier_hash'];
    }
 
    public function ‪getName()
    {
        // Do not check if file has been deleted because we might need the
        // name for undeleting it.
        return ‪$this->name;
    }
 
    public function ‪getNameWithoutExtension()
    {
        return ‪PathUtility::pathinfo($this->‪getName(), PATHINFO_FILENAME);
    }
 
    public function ‪getSize()
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821480);
        }
        if (empty($this->properties['size'])) {
            $size = array_pop($this->‪getStorage()->getFileInfoByIdentifier($this->‪getIdentifier(), ['size']));
        } else {
            $size = $this->properties['size'];
        }
        return $size ? (int)$size : null;
    }
 
    public function ‪getUid()
    {
        return (int)$this->‪getProperty('uid');
    }
 
    public function ‪getSha1()
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821481);
        }
        return $this->‪getStorage()->‪hashFile($this, 'sha1');
    }
 
    public function ‪getCreationTime()
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821487);
        }
        return (int)$this->‪getProperty('creation_date');
    }
 
    public function ‪getModificationTime()
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821488);
        }
        return (int)$this->‪getProperty('modification_date');
    }
 
    public function ‪getExtension()
    {
        $pathinfo = ‪PathUtility::pathinfo($this->‪getName());
 
        $extension = strtolower($pathinfo['extension'] ?? '');
 
        return $extension;
    }
 
    public function ‪getMimeType()
    {
        return $this->properties['mime_type'] ?: array_pop($this->‪getStorage()->getFileInfoByIdentifier($this->‪getIdentifier(), ['mimetype']));
    }
 
    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']) {
            $mimeType = $this->‪getMimeType();
            [$fileType] = explode('/', $mimeType);
            switch (strtolower($fileType)) {
                case 'text':
                    $this->properties['type'] = ‪self::FILETYPE_TEXT;
                    break;
                case 'image':
                    $this->properties['type'] = ‪self::FILETYPE_IMAGE;
                    break;
                case 'audio':
                    $this->properties['type'] = ‪self::FILETYPE_AUDIO;
                    break;
                case 'video':
                    $this->properties['type'] = ‪self::FILETYPE_VIDEO;
                    break;
                case 'application':
 
                case 'software':
                    $this->properties['type'] = ‪self::FILETYPE_APPLICATION;
                    break;
                default:
                    $this->properties['type'] = ‪self::FILETYPE_UNKNOWN;
            }
        }
        return (int)$this->properties['type'];
    }
 
    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()
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821479);
        }
        return $this->‪getStorage()->‪getFileContents($this);
    }
 
    public function ‪setContents($contents)
    {
        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()
    {
        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()
    {
        // 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($newName, $conflictMode = ‪DuplicationBehavior::RENAME)
    {
        if ($this->deleted) {
            throw new \RuntimeException('File has been deleted.', 1329821482);
        }
        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);
        }
        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);
        }
        return $targetFolder->getStorage()->moveFile($this, $targetFolder, $targetFileName, $conflictMode);
    }
 
    /*****************
     * SPECIAL METHODS
     *****************/
    public function ‪getPublicUrl($relativeToCurrentScript = false)
    {
        if ($this->deleted) {
            return null;
        }
        return $this->‪getStorage()->‪getPublicUrl($this, $relativeToCurrentScript);
    }
 
    public function ‪getForLocalProcessing($writable = true)
    {
        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()
    {
        return $this->‪getStorage()->‪getFolder($this->‪getStorage()->getFolderIdentifierFromFileIdentifier($this->‪getIdentifier()));
    }
}