ResourceFactory.php

Go to the documentation of this file.

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

use TYPO3\CMS\Core\Resource\Index\FileIndexRepository;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Core\Utility\PathUtility;

// TODO implement constructor-level caching
class ResourceFactory implements ResourceFactoryInterface, \TYPO3\CMS\Core\SingletonInterface {

    static public function getInstance() {
        return GeneralUtility::makeInstance(__CLASS__);
    }

    protected $storageInstances = array();

    protected $collectionInstances = array();

    protected $fileInstances = array();

    protected $fileReferenceInstances = array();

    protected $localDriverStorageCache = NULL;

    protected $signalSlotDispatcher;

    public function __construct(\TYPO3\CMS\Extbase\SignalSlot\Dispatcher $signalSlotDispatcher = NULL) {
        $this->signalSlotDispatcher = $signalSlotDispatcher ?: GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher');
    }

    public function getDriverObject($driverIdentificationString, array $driverConfiguration) {
        $driverRegistry = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Driver\\DriverRegistry');
        $driverClass = $driverRegistry->getDriverClass($driverIdentificationString);
        $driverObject = GeneralUtility::makeInstance($driverClass, $driverConfiguration);
        return $driverObject;
    }


    public function getDefaultStorage() {
        $storageRepository = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\StorageRepository');

        $allStorages = $storageRepository->findAll();
        foreach ($allStorages as $storage) {
            if ($storage->isDefault()) {
                return $storage;
            }
        }
        return NULL;
    }
    public function getStorageObject($uid, array $recordData = array(), &$fileIdentifier = NULL) {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('uid of Storage has to be numeric.', 1314085991);
        }
        $uid = (int)$uid;
        if ($uid === 0 && $fileIdentifier !== NULL) {
            $uid = $this->findBestMatchingStorageByLocalPath($fileIdentifier);
        }
        if (!$this->storageInstances[$uid]) {
            $storageConfiguration = NULL;
            $storageObject = NULL;
            // If the built-in storage with UID=0 is requested:
            if ($uid === 0) {
                $recordData = array(
                    'uid' => 0,
                    'pid' => 0,
                    'name' => 'Fallback Storage',
                    'description' => 'Internal storage, mounting the main TYPO3_site directory.',
                    'driver' => 'Local',
                    'processingfolder' => 'typo3temp/_processed_/',
                    // legacy code
                    'configuration' => '',
                    'is_online' => TRUE,
                    'is_browsable' => TRUE,
                    'is_public' => TRUE,
                    'is_writable' => TRUE,
                    'is_default' => FALSE,
                );
                $storageConfiguration = array(
                    'basePath' => '/',
                    'pathType' => 'relative'
                );
            } elseif (count($recordData) === 0 || (int)$recordData['uid'] !== $uid) {
                $storageRepository = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\StorageRepository');
                $storageObject = $storageRepository->findByUid($uid);
            }
            if (!$storageObject instanceof ResourceStorage) {
                $storageObject = $this->createStorageObject($recordData, $storageConfiguration);
            }
            $this->emitPostProcessStorageSignal($storageObject);
            $this->storageInstances[$uid] = $storageObject;
        }
        return $this->storageInstances[$uid];
    }

    protected function emitPostProcessStorageSignal(ResourceStorage $storageObject) {
        $this->signalSlotDispatcher->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceFactory', self::SIGNAL_PostProcessStorage, array($this, $storageObject));
    }

    protected function findBestMatchingStorageByLocalPath(&$localPath) {
        if ($this->localDriverStorageCache === NULL) {
            $this->initializeLocalStorageCache();
        }

        $bestMatchStorageUid = 0;
        $bestMatchLength = 0;
        foreach ($this->localDriverStorageCache as $storageUid => $basePath) {
            $matchLength = strlen(PathUtility::getCommonPrefix(array($basePath, $localPath)));
            $basePathLength = strlen($basePath);

            if ($matchLength >= $basePathLength && $matchLength > $bestMatchLength) {
                $bestMatchStorageUid = (int)$storageUid;
                $bestMatchLength = $matchLength;
            }
        }
        if ($bestMatchStorageUid !== 0) {
            $localPath = substr($localPath, $bestMatchLength);
        }
        return $bestMatchStorageUid;
    }

    protected function initializeLocalStorageCache() {
        $storageRepository = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\StorageRepository');
        $storageObjects = $storageRepository->findByStorageType('Local');

        $storageCache = array();
        foreach ($storageObjects as $localStorage) {
            $configuration = $localStorage->getConfiguration();
            $storageCache[$localStorage->getUid()] = $configuration['basePath'];
        }
        $this->localDriverStorageCache = $storageCache;
    }

    public function convertFlexFormDataToConfigurationArray($flexFormData) {
        $configuration = array();
        if ($flexFormData) {
            $flexFormContents = GeneralUtility::xml2array($flexFormData);
            if (!empty($flexFormContents['data']['sDEF']['lDEF']) && is_array($flexFormContents['data']['sDEF']['lDEF'])) {
                foreach ($flexFormContents['data']['sDEF']['lDEF'] as $key => $value) {
                    if (isset($value['vDEF'])) {
                        $configuration[$key] = $value['vDEF'];
                    }
                }
            }
        }
        return $configuration;
    }

    public function getCollectionObject($uid, array $recordData = array()) {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('uid of collection has to be numeric.', 1314085999);
        }
        if (!$this->collectionInstances[$uid]) {
            // Get mount data if not already supplied as argument to this function
            if (count($recordData) === 0 || $recordData['uid'] !== $uid) {
                $recordData = $GLOBALS['TYPO3_DB']->exec_SELECTgetSingleRow('*', 'sys_file_collection', 'uid=' . (int)$uid . ' AND deleted=0');
                if (!is_array($recordData)) {
                    throw new \InvalidArgumentException('No collection found for given UID.', 1314085992);
                }
            }
            $collectionObject = $this->createCollectionObject($recordData);
            $this->collectionInstances[$uid] = $collectionObject;
        }
        return $this->collectionInstances[$uid];
    }

    public function createCollectionObject(array $collectionData) {
        $registry = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Collection\\FileCollectionRegistry');
        $class = $registry->getFileCollectionClass($collectionData['type']);

        return $class::create($collectionData);
    }

    public function createStorageObject(array $storageRecord, array $storageConfiguration = NULL) {
        $className = 'TYPO3\\CMS\\Core\\Resource\\ResourceStorage';
        if (!$storageConfiguration) {
            $storageConfiguration = $this->convertFlexFormDataToConfigurationArray($storageRecord['configuration']);
        }
        $driverType = $storageRecord['driver'];
        $driverObject = $this->getDriverObject($driverType, $storageConfiguration);
        return GeneralUtility::makeInstance($className, $driverObject, $storageRecord);
    }

    public function createFolderObject(ResourceStorage $storage, $identifier, $name) {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Folder', $storage, $identifier, $name);
    }

    public function getFileObject($uid, array $fileData = array()) {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('uid of file has to be numeric.', 1300096564);
        }
        if (!$this->fileInstances[$uid]) {
            // Fetches data in case $fileData is empty
            if (empty($fileData)) {
                $fileData = $this->getFileIndexRepository()->findOneByUid($uid);
                if ($fileData === FALSE) {
                    throw new \TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException('No file found for given UID.', 1317178604);
                }
            }
            $this->fileInstances[$uid] = $this->createFileObject($fileData);
        }
        return $this->fileInstances[$uid];
    }

    public function getFileObjectFromCombinedIdentifier($identifier) {
        if (!isset($identifier) || !is_string($identifier) || $identifier === '') {
            throw new \InvalidArgumentException('Invalid file identifier given. It must be of type string and not empty. "' . gettype($identifier) . '" given.', 1401732564);
        }
        $parts = GeneralUtility::trimExplode(':', $identifier);
        if (count($parts) === 2) {
            $storageUid = $parts[0];
            $fileIdentifier = $parts[1];
        } else {
            // We only got a path: Go into backwards compatibility mode and
            // use virtual Storage (uid=0)
            $storageUid = 0;
            $fileIdentifier = $parts[0];
        }

        // please note that getStorageObject() might modify $fileIdentifier when
        // auto-detecting the best-matching storage to use
        return $this->getFileObjectByStorageAndIdentifier($storageUid, $fileIdentifier);
    }

    public function getFileObjectByStorageAndIdentifier($storageUid, &$fileIdentifier) {
        $storage = $this->getStorageObject($storageUid, array(), $fileIdentifier);
        if (!$storage->isWithinProcessingFolder($fileIdentifier)) {
            $fileData = $this->getFileIndexRepository()->findOneByStorageUidAndIdentifier($storage->getUid(), $fileIdentifier);
            if ($fileData === FALSE) {
                $fileObject = $this->getIndexer($storage)->createIndexEntry($fileIdentifier);
            } else {
                $fileObject = $this->getFileObject($fileData['uid'], $fileData);
            }
        } else {
            $fileObject = $this->getProcessedFileRepository()->findByStorageAndIdentifier($storage, $fileIdentifier);
        }

        return $fileObject;
    }

    public function retrieveFileOrFolderObject($input) {
        // Remove PATH_site because absolute paths under Windows systems contain ':'
        // This is done in all considered sub functions anyway
        $input = str_replace(PATH_site, '', $input);

        if (GeneralUtility::isFirstPartOfStr($input, 'file:')) {
            $input = substr($input, 5);
            return $this->retrieveFileOrFolderObject($input);
        } elseif (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($input)) {
            return $this->getFileObject($input);
        } elseif (strpos($input, ':') > 0) {
            list($prefix, $folderIdentifier) = explode(':', $input);
            if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($prefix)) {
                // path or folder in a valid storageUID
                return $this->getObjectFromCombinedIdentifier($input);
            } elseif ($prefix == 'EXT') {
                $input = GeneralUtility::getFileAbsFileName($input);
                if (empty($input)) {
                    return NULL;
                }
                $input = PathUtility::getRelativePath(PATH_site, dirname($input)) . basename($input);
                return $this->getFileObjectFromCombinedIdentifier($input);
            } else {
                return NULL;
            }
        } else {
            // this is a backwards-compatible way to access "0-storage" files or folders
            // eliminate double slashes, /./ and /../
            $input = \TYPO3\CMS\Core\Utility\PathUtility::getCanonicalPath(ltrim($input, '/'));
            if (@is_file(PATH_site . $input)) {
                // only the local file
                return $this->getFileObjectFromCombinedIdentifier($input);
            } else {
                // only the local path
                return $this->getFolderObjectFromCombinedIdentifier($input);
            }
        }
    }

    public function getFolderObjectFromCombinedIdentifier($identifier) {
        $parts = GeneralUtility::trimExplode(':', $identifier);
        if (count($parts) === 2) {
            $storageUid = $parts[0];
            $folderIdentifier = $parts[1];
        } else {
            // We only got a path: Go into backwards compatibility mode and
            // use virtual Storage (uid=0)
            $storageUid = 0;

            // please note that getStorageObject() might modify $folderIdentifier when
            // auto-detecting the best-matching storage to use
            $folderIdentifier = $parts[0];
            // make sure to not use an absolute path, and remove PATH_site if it is prepended
            if (GeneralUtility::isFirstPartOfStr($folderIdentifier, PATH_site)) {
                $folderIdentifier = \TYPO3\CMS\Core\Utility\PathUtility::stripPathSitePrefix($parts[0]);
            }
        }
        return $this->getStorageObject($storageUid, array(), $folderIdentifier)->getFolder($folderIdentifier);
    }

    public function getStorageObjectFromCombinedIdentifier($identifier) {
        $parts = GeneralUtility::trimExplode(':', $identifier);
        $storageUid = count($parts) === 2 ? $parts[0] : NULL;
        return $this->getStorageObject($storageUid);
    }

    public function getObjectFromCombinedIdentifier($identifier) {
        list($storageId, $objectIdentifier) = GeneralUtility::trimExplode(':', $identifier);
        $storage = $this->getStorageObject($storageId);
        if ($storage->hasFile($objectIdentifier)) {
            return $storage->getFile($objectIdentifier);
        } elseif ($storage->hasFolder($objectIdentifier)) {
            return $storage->getFolder($objectIdentifier);
        } else {
            throw new \TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException('Object with identifier "' . $identifier . '" does not exist in storage', 1329647780);
        }
    }

    public function createFileObject(array $fileData, ResourceStorage $storage = NULL) {
        if (array_key_exists('storage', $fileData) && MathUtility::canBeInterpretedAsInteger($fileData['storage'])) {
            $storageObject = $this->getStorageObject((int)$fileData['storage']);
        } elseif ($storage !== NULL) {
            $storageObject = $storage;
            $fileData['storage'] = $storage->getUid();
        } else {
            throw new \RuntimeException('A file needs to reside in a Storage', 1381570997);
        }
        $fileObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\File', $fileData, $storageObject);
        return $fileObject;
    }

    public function getFileReferenceObject($uid, array $fileReferenceData = array(), $raw = FALSE) {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('uid of file usage (sys_file_reference) has to be numeric.', 1300086584);
        }
        if (!$this->fileReferenceInstances[$uid]) {
            // Fetches data in case $fileData is empty
            if (empty($fileReferenceData)) {
                $fileReferenceData = $this->getFileReferenceData($uid, $raw);
                if (!is_array($fileReferenceData)) {
                    throw new \TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException('No file usage (sys_file_reference) found for given UID.', 1317178794);
                }
            }
            $this->fileReferenceInstances[$uid] = $this->createFileReferenceObject($fileReferenceData);
        }
        return $this->fileReferenceInstances[$uid];
    }

    public function createFileReferenceObject(array $fileReferenceData) {
        $fileReferenceObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\FileReference', $fileReferenceData);
        return $fileReferenceObject;
    }

    protected function getFileReferenceData($uid, $raw = FALSE) {
        if (!$raw && TYPO3_MODE === 'BE') {
            $fileReferenceData = \TYPO3\CMS\Backend\Utility\BackendUtility::getRecordWSOL('sys_file_reference', $uid);
        } elseif (!$raw && is_object($GLOBALS['TSFE'])) {
            $fileReferenceData = $GLOBALS['TSFE']->sys_page->checkRecord('sys_file_reference', $uid);
        } else {
            $fileReferenceData = $GLOBALS['TYPO3_DB']->exec_SELECTgetSingleRow('*', 'sys_file_reference', 'uid=' . (int)$uid . ' AND deleted=0');
        }
        return $fileReferenceData;
    }

    protected function getFileIndexRepository() {
        return FileIndexRepository::getInstance();
    }

    protected function getProcessedFileRepository() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\ProcessedFileRepository');
    }

    protected function getIndexer(ResourceStorage $storage) {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\Indexer', $storage);
    }

}