ProcessedFile.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\Processing\TaskTypeRegistry;
use ‪TYPO3\CMS\Core\Resource\Service\ConfigurationService;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
 
class ‪ProcessedFile extends ‪AbstractFile
{
    /*********************************************
     * FILE PROCESSING CONTEXTS
     *********************************************/
    public const ‪CONTEXT_IMAGEPREVIEW = 'Image.Preview';
    public const ‪CONTEXT_IMAGECROPSCALEMASK = 'Image.CropScaleMask';
 
    protected string ‪$taskType;
 
    protected ?‪Processing\TaskInterface ‪$task = null;
    protected ‪Processing\TaskTypeRegistry ‪$taskTypeRegistry;
 
    protected ?array ‪$processingConfiguration;
 
    protected ‪File ‪$originalFile;
 
    protected ?string ‪$originalFileSha1;
 
    protected bool ‪$updated = false;
 
    protected string ‪$processingUrl;
 
    public function ‪__construct(‪File ‪$originalFile, string ‪$taskType, array ‪$processingConfiguration, array $databaseRow = null)
    {
        $this->originalFile = ‪$originalFile;
        $this->originalFileSha1 = $this->originalFile->‪getSha1();
        $this->storage = ‪$originalFile->‪getStorage()->getProcessingFolder()->‪getStorage();
        $this->taskType = ‪$taskType;
        $this->processingConfiguration = ‪$processingConfiguration;
        if (is_array($databaseRow)) {
            $this->‪reconstituteFromDatabaseRecord($databaseRow);
        }
        $this->taskTypeRegistry = GeneralUtility::makeInstance(TaskTypeRegistry::class);
    }
 
    protected function ‪reconstituteFromDatabaseRecord(array $databaseRow): void
    {
        $this->taskType = $this->taskType ?: $databaseRow['task_type'];
        // @todo In case the original configuration contained file objects the reconstitution fails. See ConfigurationService->serialize()
        $this->processingConfiguration = $this->processingConfiguration ?: (array)unserialize($databaseRow['configuration'] ?? '');
 
        $this->originalFileSha1 = $databaseRow['originalfilesha1'];
        $this->identifier = $databaseRow['identifier'];
        $this->name = $databaseRow['name'];
        $this->‪properties = $databaseRow;
        $this->processingUrl = $databaseRow['processing_url'] ?? '';
 
        if (!empty($databaseRow['storage']) && (int)$this->storage->getUid() !== (int)$databaseRow['storage']) {
            $this->storage = GeneralUtility::makeInstance(StorageRepository::class)->findByUid($databaseRow['storage']);
        }
    }
 
    /********************************
     * VARIOUS FILE PROPERTY GETTERS
     ********************************/
 
    protected function ‪calculateChecksum(): string
    {
        return $this->‪getTask()->getConfigurationChecksum();
    }
 
    /*******************
     * CONTENTS RELATED
     *******************/
    public function ‪setContents(string $contents): self
    {
        throw new \BadMethodCallException('Setting contents not possible for processed file.', 1305438528);
    }
 
    public function ‪updateWithLocalFile(string $filePath): void
    {
        if (empty($this->identifier)) {
            throw new \RuntimeException('Cannot update original file!', 1350582054);
        }
        $processingFolder = $this->originalFile->getStorage()->getProcessingFolder($this->originalFile);
        $addedFile = $this->storage->updateProcessedFile($filePath, $this, $processingFolder);
 
        // Update some related properties
        $this->identifier = $addedFile->getIdentifier();
        $this->originalFileSha1 = $this->originalFile->getSha1();
        if ($addedFile instanceof ‪AbstractFile) {
            $this->‪updateProperties($addedFile->getProperties());
        }
        $this->deleted = false;
        $this->updated = true;
    }
 
    /*****************************************
     * STORAGE AND MANAGEMENT RELATED METHODS
     *****************************************/
    public function ‪isIndexed(): bool
    {
        // Processed files are never indexed; instead you might be looking for isPersisted()
        return false;
    }
 
    public function ‪isPersisted(): bool
    {
        return array_key_exists('uid', $this->‪properties) && $this->‪properties['uid'] > 0;
    }
 
    public function ‪isNew(): bool
    {
        return !$this->‪isPersisted();
    }
 
    public function ‪isUpdated(): bool
    {
        return ‪$this->updated;
    }
 
    public function ‪setName(string ‪$name): void
    {
        // Remove the existing file, but only we actually have a name or the name has changed
        if (!empty($this->name) && $this->name !== ‪$name && $this->‪exists()) {
            $this->delete();
        }
 
        $this->name = ‪$name;
        // @todo this is a *weird* hack that will fail if the storage is non-hierarchical!
        $this->identifier = $this->storage->getProcessingFolder($this->originalFile)->getIdentifier() . ‪$this->name;
 
        $this->updated = true;
    }
 
    public function ‪exists(): bool
    {
        if ($this->‪usesOriginalFile()) {
            return $this->originalFile->exists();
        }
 
        return parent::exists();
    }
 
    /******************
     * SPECIAL METHODS
     ******************/
 
    public function ‪isProcessed(): bool
    {
        return $this->updated || ($this->‪isPersisted() && !$this->‪needsReprocessing());
    }
 
    public function ‪getOriginalFile(): ‪File
    {
        return ‪$this->originalFile;
    }
 
    public function ‪getIdentifier(): string
    {
        return (!$this->‪usesOriginalFile()) ? $this->identifier : $this->‪getOriginalFile()->getIdentifier();
    }
 
    public function ‪getName(): string
    {
        if ($this->‪usesOriginalFile()) {
            return $this->originalFile->getName();
        }
        return ‪$this->name;
    }
 
    public function ‪updateProperties(array ‪$properties): void
    {
        if (array_key_exists('uid', ‪$properties) && ‪MathUtility::canBeInterpretedAsInteger(‪$properties['uid'])) {
            $this->‪properties['uid'] = $properties['uid'];
        }
        if (isset(‪$properties['processing_url'])) {
            $this->processingUrl = ‪$properties['processing_url'];
        }
 
        // @todo we should have a blacklist of properties that might not be updated
        $this->‪properties = array_merge($this->‪properties, $properties);
 
        // @todo when should this update be done?
        if (!$this->‪isUnchanged() && $this->‪exists()) {
            ‪$storage = ‪$this->storage;
            if ($this->‪usesOriginalFile()) {
                ‪$storage = $this->originalFile->getStorage();
            }
            $this->‪properties = array_merge($this->‪properties, ‪$storage->‪getFileInfo($this));
        }
    }
 
    public function toArray(): array
    {
        if ($this->‪usesOriginalFile()) {
            ‪$properties = $this->originalFile->getProperties();
            unset(‪$properties['uid']);
            ‪$properties['identifier'] = '';
            ‪$properties['name'] = null;
            ‪$properties['processing_url'] = '';
 
            // Use width + height set in processed file
            ‪$properties['width'] = $this->‪properties['width'] ?? 0;
            ‪$properties['height'] = $this->‪properties['height'] ?? 0;
        } else {
            ‪$properties = ‪$this->properties;
            ‪$properties['identifier'] = $this->‪getIdentifier();
            ‪$properties['name'] = $this->‪getName();
        }
 
        ‪$properties['configuration'] = (new ConfigurationService())->serialize($this->processingConfiguration);
 
        return array_merge(‪$properties, [
            'storage' => $this->‪getStorage()->‪getUid(),
            'checksum' => $this->‪calculateChecksum(),
            'task_type' => $this->taskType,
            'configurationsha1' => sha1(‪$properties['configuration']),
            'original' => $this->originalFile->getUid(),
            'originalfilesha1' => $this->originalFileSha1,
        ]);
    }
 
    protected function ‪isUnchanged(): bool
    {
        return !($this->‪properties['width'] ?? false) && $this->‪usesOriginalFile();
    }
 
    public function ‪setUsesOriginalFile(): void
    {
        // @todo check if some of these properties can/should be set in a generic update method
        $this->identifier = $this->originalFile->getIdentifier();
        $this->updated = true;
        $this->processingUrl = '';
        $this->originalFileSha1 = $this->originalFile->getSha1();
    }
 
    public function ‪updateProcessingUrl(string ‪$url): void
    {
        $this->updated = true;
        $this->processingUrl = ‪$url;
    }
 
    public function ‪usesOriginalFile(): bool
    {
        return empty($this->identifier) || $this->identifier === $this->originalFile->getIdentifier();
    }
 
    public function ‪isOutdated(): bool
    {
        return $this->‪needsReprocessing();
    }
 
    public function delete(bool $force = false): bool
    {
        if (!$force && $this->‪isUnchanged()) {
            return false;
        }
        // Only delete file when original isn't used
        if (!$this->‪usesOriginalFile()) {
            return parent::delete();
        }
        return true;
    }
 
    public function ‪getProperty(string $key): mixed
    {
        // The uid always (!) has to come from this file and never the original file (see getOriginalFile() to get this)
        if ($this->‪isUnchanged() && $key !== 'uid') {
            return $this->originalFile->getProperty($key);
        }
        return $this->‪properties[$key] ?? null;
    }
 
    public function ‪getMimeType(): string
    {
        if ($this->‪usesOriginalFile()) {
            return $this->‪getOriginalFile()->getMimeType();
        }
        return parent::getMimeType();
    }
 
    public function getSize(): int
    {
        if ($this->‪usesOriginalFile()) {
            return $this->‪getOriginalFile()->getSize();
        }
        return parent::getSize();
    }
 
    public function ‪getUid(): int
    {
        return (int)($this->‪properties['uid'] ?? 0);
    }
 
    public function ‪needsReprocessing(): bool
    {
        $fileMustBeRecreated = false;
 
        // if original is missing we can not reprocess the file
        if ($this->originalFile->isMissing()) {
            return false;
        }
 
        // processedFile does not exist
        if (!$this->‪usesOriginalFile() && !$this->‪exists()) {
            $fileMustBeRecreated = true;
        }
 
        // hash does not match
        if (array_key_exists('checksum', $this->‪properties) && $this->‪calculateChecksum() !== $this->‪properties['checksum']) {
            $fileMustBeRecreated = true;
        }
 
        // original file changed
        if ($this->originalFile->getSha1() !== $this->originalFileSha1) {
            $fileMustBeRecreated = true;
        }
 
        if (!array_key_exists('uid', $this->‪properties)) {
            $fileMustBeRecreated = true;
        }
 
        // remove outdated file
        if ($fileMustBeRecreated && $this->‪exists()) {
            $this->delete();
        }
        return $fileMustBeRecreated;
    }
 
    public function ‪getProcessingConfiguration(): array
    {
        return ‪$this->processingConfiguration;
    }
 
    public function ‪getTaskIdentifier(): string
    {
        return ‪$this->taskType;
    }
 
    public function ‪getTask(): Processing\‪TaskInterface
    {
        if ($this->task === null) {
            $this->task = $this->taskTypeRegistry->getTaskForType($this->taskType, $this, $this->processingConfiguration);
        }
 
        return ‪$this->task;
    }
 
    public function ‪generateProcessedFileNameWithoutExtension(): string
    {
        ‪$name = $this->originalFile->getNameWithoutExtension();
        ‪$name .= '_' . $this->originalFile->getUid();
        ‪$name .= '_' . $this->‪calculateChecksum();
 
        return ‪$name;
    }
 
    public function ‪getPublicUrl(): ?string
    {
        if (isset($this->processingUrl) && $this->processingUrl !== '') {
            return ‪$this->processingUrl;
        }
        if ($this->deleted) {
            return null;
        }
        if ($this->‪usesOriginalFile()) {
            return $this->‪getOriginalFile()->getPublicUrl();
        }
        return $this->‪getStorage()->‪getPublicUrl($this);
    }
}