ProcessedFile.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Resource;

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->storage = $originalFile->getStorage()->getProcessingFolder()->getStorage();
        $this->taskType = $taskType;
        $this->processingConfiguration = $processingConfiguration;
        if (is_array($databaseRow)) {
            $this->reconstituteFromDatabaseRecord($databaseRow);
        }
        $this->taskTypeRegistry = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Processing\\TaskTypeRegistry');
    }

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

    /********************************
     * 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 ($this->identifier === NULL) {
            throw new \RuntimeException('Cannot update original file!', 1350582054);
        }
        $processingFolder = $this->originalFile->getStorage()->getProcessingFolder();
        $addedFile = $this->storage->updateProcessedFile($filePath, $this, $processingFolder);

        // Update some related properties
        $this->identifier = $addedFile->getIdentifier();
        $this->originalFileSha1 = $this->originalFile->getSha1();
        $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
        if ($this->name !== $name && $this->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()->getIdentifier() . $this->name;

        $this->updated = TRUE;
    }

    /******************
     * 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();
        } else {
            return $this->name;
        }
    }

    public function updateProperties(array $properties) {
        if (!is_array($this->properties)) {
            $this->properties = array();
        }

        if (array_key_exists('uid', $properties) && \TYPO3\CMS\Core\Utility\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']);
            unset($properties['width']);
            unset($properties['height']);
        } else {
            $properties = $this->properties;
            $properties['identifier'] = $this->getIdentifier();
            $properties['name'] = $this->getName();
        }

        $properties['configuration'] = serialize($this->processingConfiguration);

        return array_merge($properties, array(
            '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->identifier == NULL || $this->identifier === $this->originalFile->getIdentifier();
    }

    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 $this->isUnchanged();
    }

    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();
        } else {
            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);
        } else {
            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;
        } elseif ($this->usesOriginalFile()) {
            return $this->getOriginalFile()->getPublicUrl($relativeToCurrentScript);
        } else {
            return $this->getStorage()->getPublicUrl($this, $relativeToCurrentScript);
        }
    }
}