9.5/_processed_file_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Resource;


/*

 * 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!

 */


use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\MathUtility;


class ‪ProcessedFile extends ‪AbstractFile

{

    /*********************************************

     * FILE PROCESSING CONTEXTS

     *********************************************/

    const ‪CONTEXT_IMAGEPREVIEW = 'Image.Preview';

    const ‪CONTEXT_IMAGECROPSCALEMASK = 'Image.CropScaleMask';


    protected ‪$taskType;


    protected ‪$task;


    protected ‪$taskTypeRegistry;


    protected ‪$processingConfiguration;


    protected ‪$originalFile;


    protected ‪$originalFileSha1;


    protected ‪$updated = false;


    public function ‪__construct(‪File ‪$originalFile, ‪$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(Processing\TaskTypeRegistry::class);

    }


    protected function ‪reconstituteFromDatabaseRecord(array $databaseRow)

    {

        $this->taskType = $this->taskType ?: $databaseRow['task_type'];

        $this->processingConfiguration = $this->processingConfiguration ?: unserialize($databaseRow['configuration']);


        $this->originalFileSha1 = $databaseRow['originalfilesha1'];

        $this->identifier = $databaseRow['identifier'];

        $this->name = $databaseRow['name'];

        $this->properties = $databaseRow;


        if (!empty($databaseRow['storage']) && (int)$this->storage->getUid() !== (int)$databaseRow['storage']) {

            $this->storage = ‪ResourceFactory::getInstance()->‪getStorageObject($databaseRow['storage']);

        }

    }


    /********************************

     * VARIOUS FILE PROPERTY GETTERS

     ********************************/


    // @todo replace these usages with direct calls to the task object

    public function ‪calculateChecksum()

    {

        return $this->‪getTask()->getConfigurationChecksum();

    }


    /*******************

     * CONTENTS RELATED

     *******************/

    public function ‪setContents($contents)

    {

        throw new \BadMethodCallException('Setting contents not possible for processed file.', 1305438528);

    }


    public function ‪updateWithLocalFile($filePath)

    {

        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 METHDOS

     *****************************************/

    public function ‪isIndexed()

    {

        // Processed files are never indexed; instead you might be looking for isPersisted()

        return false;

    }


    public function ‪isPersisted()

    {

        return is_array($this->properties) && array_key_exists('uid', $this->properties) && $this->properties['uid'] > 0;

    }


    public function ‪isNew()

    {

        return !$this->‪isPersisted();

    }


    public function ‪isUpdated()

    {

        return ‪$this->updated;

    }


    public function ‪setName(‪$name)

    {

        // 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()

    {

        if ($this->‪usesOriginalFile()) {

            return $this->originalFile->exists();

        }


        return parent::exists();

    }


    /******************

     * SPECIAL METHODS

     ******************/


    public function ‪isProcessed()

    {

        return $this->updated || ($this->‪isPersisted() && !$this->‪needsReprocessing());

    }


    public function ‪getOriginalFile()

    {

        return ‪$this->originalFile;

    }


    public function ‪getIdentifier()

    {

        return (!$this->‪usesOriginalFile()) ? $this->identifier : $this->‪getOriginalFile()->‪getIdentifier();

    }


    public function ‪getName()

    {

        if ($this->‪usesOriginalFile()) {

            return $this->originalFile->getName();

        }

        return ‪$this->name;

    }


    public function ‪updateProperties(array ‪$properties)

    {

        if (!is_array($this->properties)) {

            $this->properties = [];

        }


        if (array_key_exists('uid', ‪$properties) && ‪MathUtility::canBeInterpretedAsInteger(‪$properties['uid'])) {

            $this->properties['uid'] = ‪$properties['uid'];

        }


        // @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()) {

            $this->properties = array_merge($this->properties, $this->storage->getFileInfo($this));

        }

    }


    public function ‪toArray()

    {

        if ($this->‪usesOriginalFile()) {

            ‪$properties = $this->originalFile->getProperties();

            unset(‪$properties['uid']);

            unset(‪$properties['pid']);

            unset(‪$properties['identifier']);

            unset(‪$properties['name']);


            // Use width + height set in processed file

            ‪$properties['width'] = $this->properties['width'];

            ‪$properties['height'] = $this->properties['height'];

        } else {

            ‪$properties = ‪$this->properties;

            ‪$properties['identifier'] = $this->‪getIdentifier();

            ‪$properties['name'] = $this->‪getName();

        }


        ‪$properties['configuration'] = 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()

    {

        return !$this->properties['width'] && $this->‪usesOriginalFile();

    }


    public function ‪setUsesOriginalFile()

    {

        // @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->originalFileSha1 = $this->originalFile->getSha1();

    }


    public function ‪usesOriginalFile()

    {

        return empty($this->identifier) || $this->identifier === $this->originalFile->getIdentifier();

    }


    public function ‪isOutdated()

    {

        return $this->‪needsReprocessing();

    }


    public function delete($force = false)

    {

        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($key)

    {

        // 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];

    }


    public function ‪getUid()

    {

        return $this->properties['uid'];

    }


    public function ‪needsReprocessing()

    {

        $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()

    {

        return ‪$this->processingConfiguration;

    }


    public function ‪getTaskIdentifier()

    {

        return ‪$this->taskType;

    }


    public function ‪getTask()

    {

        if ($this->task == null) {

            $this->task = $this->taskTypeRegistry->getTaskForType($this->taskType, $this, $this->processingConfiguration);

        }


        return ‪$this->task;

    }


    public function ‪generateProcessedFileNameWithoutExtension()

    {

        ‪$name = $this->originalFile->getNameWithoutExtension();

        ‪$name .= '_' . $this->originalFile->getUid();

        ‪$name .= '_' . $this->‪calculateChecksum();


        return ‪$name;

    }


    public function ‪getPublicUrl($relativeToCurrentScript = false)

    {

        if ($this->deleted) {

            return null;

        }

        if ($this->‪usesOriginalFile()) {

            return $this->‪getOriginalFile()->‪getPublicUrl($relativeToCurrentScript);

        }

        return $this->‪getStorage()->‪getPublicUrl($this, $relativeToCurrentScript);

    }

}