File.php

Go to the documentation of this file.

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

use TYPO3\CMS\Core\Utility\GeneralUtility;

class File extends AbstractFile {

    protected $metaDataLoaded = FALSE;

    protected $metaDataProperties = array();

    protected $indexingInProgress = FALSE;

    protected $updatedProperties = array();

    protected $indexerService = NULL;

    public function __construct(array $fileData, ResourceStorage $storage, $metaData = array()) {
        $this->identifier = $fileData['identifier'];
        $this->name = $fileData['name'];
        $this->properties = $fileData;
        $this->storage = $storage;
        if ($metaData !== array()) {
            $this->metaDataLoaded = TRUE;
            $this->metaDataProperties = $metaData;
        }
    }

    /*******************************
     * VARIOUS FILE PROPERTY GETTERS
     *******************************/
    public function getProperty($key) {
        if (parent::hasProperty($key)) {
            return parent::getProperty($key);
        } else {
            if (!$this->metaDataLoaded) {
                $this->loadMetaData();
            }
            return array_key_exists($key, $this->metaDataProperties) ? $this->metaDataProperties[$key] : NULL;
        }
    }

    public function hasProperty($key) {
        if (!parent::hasProperty($key)) {
            if (!$this->metaDataLoaded) {
                $this->loadMetaData();
            }
            return array_key_exists($key, $this->metaDataProperties);
        }
        return TRUE;
    }


    public function getProperties() {
        if (!$this->metaDataLoaded) {
            $this->loadMetaData();
        }
        return array_merge(parent::getProperties(), array_diff_key((array)$this->metaDataProperties, parent::getProperties()));
    }

    public function _getMetaData() {
        if (!$this->metaDataLoaded) {
            $this->loadMetaData();
        }
        return $this->metaDataProperties;
    }

    /******************
     * CONTENTS RELATED
     ******************/
    public function getContents() {
        return $this->getStorage()->getFileContents($this);
    }

    public function getSha1() {
        if (empty($this->properties['sha1'])) {
            $this->properties['sha1'] = parent::getSha1();
        }
        return $this->properties['sha1'];
    }

    public function setContents($contents) {
        $this->getStorage()->setFileContents($this, $contents);
        return $this;
    }

    /***********************
     * INDEX RELATED METHODS
     ***********************/
    public function isIndexed() {
        return TRUE;
    }

    protected function loadMetaData() {
        if (!$this->indexingInProgress) {
            $this->indexingInProgress = TRUE;
            $this->metaDataProperties = $this->getMetaDataRepository()->findByFile($this);
            $this->metaDataLoaded = TRUE;
            $this->indexingInProgress = FALSE;
        }

    }

    public function updateProperties(array $properties) {
        // Setting identifier and name to update values; we have to do this
        // here because we might need a new identifier when loading
        // (and thus possibly indexing) a file.
        if (isset($properties['identifier'])) {
            $this->identifier = $properties['identifier'];
        }
        if (isset($properties['name'])) {
            $this->name = $properties['name'];
        }

        if ($this->properties['uid'] != 0 && isset($properties['uid'])) {
            unset($properties['uid']);
        }
        foreach ($properties as $key => $value) {
            if ($this->properties[$key] !== $value) {
                if (!in_array($key, $this->updatedProperties)) {
                    $this->updatedProperties[] = $key;
                }
                $this->properties[$key] = $value;
            }
        }
        // If the mime_type property should be updated and it was changed also update the type.
        if (array_key_exists('mime_type', $properties) && in_array('mime_type', $this->updatedProperties)) {
            $this->updatedProperties[] = 'type';
            unset($this->properties['type']);
            $this->getType();
        }
        if (array_key_exists('storage', $properties) && in_array('storage', $this->updatedProperties)) {
            $this->storage = ResourceFactory::getInstance()->getStorageObject($properties['storage']);
        }
    }

    public function _updateMetaDataProperties(array $properties) {
        if ($this->metaDataProperties !== NULL) {
            $this->metaDataProperties = array_merge($this->metaDataProperties, $properties);
        } else {
            $this->metaDataProperties = $properties;
        }
    }

    public function getUpdatedProperties() {
        return $this->updatedProperties;
    }

    /****************************************
     * STORAGE AND MANAGEMENT RELATED METHODS
     ****************************************/
    public function checkActionPermission($action) {
        return $this->getStorage()->checkFileActionPermission($action, $this);
    }

    /*****************
     * SPECIAL METHODS
     *****************/
    public function calculateChecksum() {
        return md5(
            $this->getCombinedIdentifier() . '|' .
            $this->getMimeType() . '|' .
            $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']
        );
    }

    public function process($taskType, array $configuration) {
        return $this->getStorage()->processFile($this, $taskType, $configuration);
    }

    public function toArray() {
        $array = array(
            'id' => $this->getCombinedIdentifier(),
            'name' => $this->getName(),
            'extension' => $this->getExtension(),
            'type' => $this->getType(),
            'mimetype' => $this->getMimeType(),
            'size' => $this->getSize(),
            'url' => $this->getPublicUrl(),
            'indexed' => TRUE,
            'uid' => $this->getUid(),
            'permissions' => array(
                'read' => $this->checkActionPermission('read'),
                'write' => $this->checkActionPermission('write'),
                'delete' => $this->checkActionPermission('delete')
            ),
            'checksum' => $this->calculateChecksum()
        );
        foreach ($this->properties as $key => $value) {
            $array[$key] = $value;
        }
        $stat = $this->getStorage()->getFileInfo($this);
        foreach ($stat as $key => $value) {
            $array[$key] = $value;
        }
        return $array;
    }

    public function isMissing() {
        return (bool) $this->getProperty('missing');
    }

    public function setMissing($missing) {
        $this->updateProperties(array('missing' => $missing ? 1 : 0));
    }

    public function getPublicUrl($relativeToCurrentScript = FALSE) {
        if ($this->isMissing() || $this->deleted) {
            return FALSE;
        } else {
            return $this->getStorage()->getPublicUrl($this, $relativeToCurrentScript);
        }
    }

    protected function getMetaDataRepository() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\MetaDataRepository');
    }

    protected function getFileIndexRepository() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\FileIndexRepository');
    }

    protected function getIndexerService() {
        if ($this->indexerService === NULL) {
            $this->indexerService = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\Indexer', $this->storage);
        }
        return $this->indexerService;
    }

    public function setIndexingInProgess($indexingState) {
        $this->indexingInProgress = (boolean)$indexingState;
    }

    public function _getPropertyRaw($key) {
        return parent::getProperty($key);
    }
}