ResourceFactory.php

Go to the documentation of this file.

<?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\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Resource\Index\FileIndexRepository;
use ‪TYPO3\CMS\Core\Service\FlexFormService;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
 
class ‪ResourceFactory implements ‪ResourceFactoryInterface, ‪\TYPO3\CMS\Core\SingletonInterface
{
    public static function ‪getInstance()
    {
        return GeneralUtility::makeInstance(__CLASS__);
    }
 
    protected ‪$storageInstances = [];
 
    protected ‪$collectionInstances = [];
 
    protected ‪$fileInstances = [];
 
    protected ‪$fileReferenceInstances = [];
 
    protected $localDriverStorageCache;
 
    protected ‪$signalSlotDispatcher;
 
    public function __construct(‪Dispatcher ‪$signalSlotDispatcher = null)
    {
        $this->‪signalSlotDispatcher = ‪$signalSlotDispatcher ?: GeneralUtility::makeInstance(Dispatcher::class);
    }
 
    public function ‪getDriverObject($driverIdentificationString, array $driverConfiguration)
    {
        $driverRegistry = GeneralUtility::makeInstance(Driver\DriverRegistry::class);
        $driverClass = $driverRegistry->getDriverClass($driverIdentificationString);
        $driverObject = GeneralUtility::makeInstance($driverClass, $driverConfiguration);
        return $driverObject;
    }
 
    public function ‪getDefaultStorage()
    {
        $storageRepository = GeneralUtility::makeInstance(StorageRepository::class);
 
        $allStorages = $storageRepository->findAll();
        foreach ($allStorages as $storage) {
            if ($storage->isDefault()) {
                return $storage;
            }
        }
        return null;
    }
    public function ‪getStorageObject($uid, array $recordData = [], &$fileIdentifier = null)
    {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('The UID of storage has to be numeric. UID given: "' . $uid . '"', 1314085991);
        }
        $uid = (int)$uid;
        if ($uid === 0 && $fileIdentifier !== null) {
            $uid = $this->‪findBestMatchingStorageByLocalPath($fileIdentifier);
        }
        if (empty($this->storageInstances[$uid])) {
            $storageConfiguration = null;
            list($_, $uid, $recordData, $fileIdentifier) = $this->‪emitPreProcessStorageSignal($uid, $recordData, $fileIdentifier);
            // If the built-in storage with UID=0 is requested:
            if ($uid === 0) {
                $recordData = [
                    'uid' => 0,
                    'pid' => 0,
                    'name' => 'Fallback Storage',
                    'description' => 'Internal storage, mounting the main TYPO3_site directory.',
                    'driver' => 'Local',
                    'processingfolder' => 'typo3temp/assets/_processed_/',
                    // legacy code
                    'configuration' => '',
                    'is_online' => true,
                    'is_browsable' => true,
                    'is_public' => true,
                    'is_writable' => true,
                    'is_default' => false,
                ];
                $storageConfiguration = [
                    'basePath' => '/',
                    'pathType' => 'relative'
                ];
            } elseif ($recordData === [] || (int)$recordData['uid'] !== $uid) {
                $storageRepository = GeneralUtility::makeInstance(StorageRepository::class);
                $recordData = $storageRepository->fetchRowByUid($uid);
            }
            $storageObject = $this->‪createStorageObject($recordData, $storageConfiguration);
            $this->‪emitPostProcessStorageSignal($storageObject);
            $this->storageInstances[$uid] = $storageObject;
        }
        return $this->storageInstances[$uid];
    }
 
    protected function ‪emitPreProcessStorageSignal($uid, $recordData, $fileIdentifier)
    {
        return $this->‪signalSlotDispatcher->dispatch(\‪TYPO3\CMS\Core\Resource\ResourceFactory::class, self::SIGNAL_PreProcessStorage, [$this, $uid, $recordData, $fileIdentifier]);
    }
 
    protected function ‪emitPostProcessStorageSignal(‪ResourceStorage $storageObject)
    {
        $this->‪signalSlotDispatcher->dispatch(self::class, self::SIGNAL_PostProcessStorage, [$this, $storageObject]);
    }
 
    protected function ‪findBestMatchingStorageByLocalPath(&$localPath)
    {
        if ($this->localDriverStorageCache === null) {
            $this->‪initializeLocalStorageCache();
        }
 
        // normalize path information (`//`, `../`)
        $localPath = ‪PathUtility::getCanonicalPath($localPath);
        if ($localPath[0] !== '/') {
            $localPath = '/' . $localPath;
        }
        $bestMatchStorageUid = 0;
        $bestMatchLength = 0;
        foreach ($this->localDriverStorageCache as $storageUid => $basePath) {
            // try to match (resolved) relative base-path
            if ($basePath->getRelative() !== null
                && null !== $commonPrefix = ‪PathUtility::getCommonPrefix([$basePath->getRelative(), $localPath])
            ) {
                $matchLength = strlen($commonPrefix);
                $basePathLength = strlen($basePath->getRelative());
                if ($matchLength >= $basePathLength && $matchLength > $bestMatchLength) {
                    $bestMatchStorageUid = $storageUid;
                    $bestMatchLength = $matchLength;
                }
            }
            // try to match (resolved) absolute base-path
            if (null !== $commonPrefix = ‪PathUtility::getCommonPrefix([$basePath->getAbsolute(), $localPath])) {
                $matchLength = strlen($commonPrefix);
                $basePathLength = strlen($basePath->getAbsolute());
                if ($matchLength >= $basePathLength && $matchLength > $bestMatchLength) {
                    $bestMatchStorageUid = $storageUid;
                    $bestMatchLength = $matchLength;
                }
            }
        }
        if ($bestMatchLength > 0) {
            // $commonPrefix always has trailing slash, which needs to be excluded
            // (commonPrefix: /some/path/, localPath: /some/path/file.png --> /file.png; keep leading slash)
            $localPath = substr($localPath, $bestMatchLength - 1);
        }
        return $bestMatchStorageUid;
    }
 
    protected function ‪initializeLocalStorageCache()
    {
        $storageRepository = GeneralUtility::makeInstance(StorageRepository::class);
        $storageObjects = $storageRepository->findByStorageType('Local');
 
        $this->localDriverStorageCache = [
            // implicit legacy storage in project's public path
            0 => new ‪LocalPath('/', ‪LocalPath::TYPE_RELATIVE)
        ];
        foreach ($storageObjects as $localStorage) {
            $configuration = $localStorage->getConfiguration();
            if (!isset($configuration['basePath']) || !isset($configuration['pathType'])) {
                continue;
            }
            if ($configuration['pathType'] === 'relative') {
                $pathType = ‪LocalPath::TYPE_RELATIVE;
            } elseif ($configuration['pathType'] === 'absolute') {
                $pathType = ‪LocalPath::TYPE_ABSOLUTE;
            } else {
                continue;
            }
            $this->localDriverStorageCache[$localStorage->getUid()] = GeneralUtility::makeInstance(
                LocalPath::class,
                $configuration['basePath'],
                $pathType
            );
        }
    }
 
    public function ‪convertFlexFormDataToConfigurationArray($flexFormData)
    {
        $configuration = [];
        if ($flexFormData) {
            $flexFormService = GeneralUtility::makeInstance(FlexFormService::class);
            $configuration = $flexFormService->convertFlexFormContentToArray($flexFormData);
        }
        return $configuration;
    }
 
    public function ‪getCollectionObject($uid, array $recordData = [])
    {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('The UID of collection has to be numeric. UID given: "' . $uid . '"', 1314085999);
        }
        if (!$this->collectionInstances[$uid]) {
            // Get mount data if not already supplied as argument to this function
            if (empty($recordData) || $recordData['uid'] !== $uid) {
                $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file_collection');
                $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));
                $recordData = $queryBuilder->select('*')
                    ->from('sys_file_collection')
                    ->where(
                        $queryBuilder->expr()->eq(
                            'uid',
                            $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                        )
                    )
                    ->execute()
                    ->fetch();
                if (empty($recordData)) {
                    throw new \InvalidArgumentException('No collection found for given UID: "' . $uid . '"', 1314085992);
                }
            }
            $collectionObject = $this->‪createCollectionObject($recordData);
            $this->collectionInstances[$uid] = $collectionObject;
        }
        return $this->collectionInstances[$uid];
    }
 
    public function ‪createCollectionObject(array $collectionData)
    {
        $registry = GeneralUtility::makeInstance(Collection\FileCollectionRegistry::class);
 
        $class = $registry->getFileCollectionClass($collectionData['type']);
 
        return $class::create($collectionData);
    }
 
    public function ‪createStorageObject(array $storageRecord, array $storageConfiguration = null)
    {
        if (!$storageConfiguration) {
            $storageConfiguration = $this->‪convertFlexFormDataToConfigurationArray($storageRecord['configuration']);
        }
        $driverType = $storageRecord['driver'];
        $driverObject = $this->‪getDriverObject($driverType, $storageConfiguration);
        return GeneralUtility::makeInstance(ResourceStorage::class, $driverObject, $storageRecord);
    }
 
    public function ‪createFolderObject(ResourceStorage $storage, $identifier, $name)
    {
        return GeneralUtility::makeInstance(Folder::class, $storage, $identifier, $name);
    }
 
    public function ‪getFileObject($uid, array $fileData = [])
    {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException('The UID of file has to be numeric. UID given: "' . $uid . '"', 1300096564);
        }
        if (empty($this->fileInstances[$uid])) {
            // Fetches data in case $fileData is empty
            if (empty($fileData)) {
                $fileData = $this->‪getFileIndexRepository()->‪findOneByUid($uid);
                if ($fileData === false) {
                    throw new Exception\FileDoesNotExistException('No file found for given UID: ' . $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, [], $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 Environment::getPublicPath() because absolute paths under Windows systems contain ':'
        // This is done in all considered sub functions anyway
        $input = str_replace(‪Environment::getPublicPath() . '/', '', $input);
 
        if (GeneralUtility::isFirstPartOfStr($input, 'file:')) {
            $input = substr($input, 5);
            return $this->‪retrieveFileOrFolderObject($input);
        }
        if (‪MathUtility::canBeInterpretedAsInteger($input)) {
            return $this->‪getFileObject($input);
        }
        if (strpos($input, ':') > 0) {
            list($prefix) = explode(':', $input);
            if (‪MathUtility::canBeInterpretedAsInteger($prefix)) {
                // path or folder in a valid storageUID
                return $this->‪getObjectFromCombinedIdentifier($input);
            }
            if ($prefix === 'EXT') {
                $input = GeneralUtility::getFileAbsFileName($input);
                if (empty($input)) {
                    return null;
                }
 
                $input = ‪PathUtility::getRelativePath(‪Environment::getPublicPath() . '/', ‪PathUtility::dirname($input)) . ‪PathUtility::basename($input);
                return $this->‪getFileObjectFromCombinedIdentifier($input);
            }
            return null;
        }
        // this is a backwards-compatible way to access "0-storage" files or folders
        // eliminate double slashes, /./ and /../
        $input = ‪PathUtility::getCanonicalPath(ltrim($input, '/'));
        if (@is_file(‪Environment::getPublicPath() . '/' . $input)) {
            // only the local file
            return $this->‪getFileObjectFromCombinedIdentifier($input);
        }
        // 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 Environment::getPublicPath if it is prepended
            if (GeneralUtility::isFirstPartOfStr($folderIdentifier, ‪Environment::getPublicPath() . '/')) {
                $folderIdentifier = ‪PathUtility::stripPathSitePrefix($parts[0]);
            }
        }
        return $this->‪getStorageObject($storageUid, [], $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);
        }
        if ($storage->hasFolder($objectIdentifier)) {
            return $storage->getFolder($objectIdentifier);
        }
        throw new 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(File::class, $fileData, $storageObject);
        return $fileObject;
    }
 
    public function ‪getFileReferenceObject($uid, array $fileReferenceData = [], $raw = false)
    {
        if (!is_numeric($uid)) {
            throw new \InvalidArgumentException(
                'The reference UID for the file (sys_file_reference) has to be numeric. UID given: "' . $uid . '"',
                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 Exception\ResourceDoesNotExistException(
                        'No file reference (sys_file_reference) was found for given UID: "' . $uid . '"',
                        1317178794
                    );
                }
            }
            $this->fileReferenceInstances[$uid] = $this->‪createFileReferenceObject($fileReferenceData);
        }
        return $this->fileReferenceInstances[$uid];
    }
 
    public function ‪createFileReferenceObject(array $fileReferenceData)
    {
        $fileReferenceObject = GeneralUtility::makeInstance(FileReference::class, $fileReferenceData);
        return $fileReferenceObject;
    }
 
    protected function ‪getFileReferenceData($uid, $raw = false)
    {
        if (!$raw && TYPO3_MODE === 'BE') {
            $fileReferenceData = ‪BackendUtility::getRecordWSOL('sys_file_reference', $uid);
        } elseif (!$raw && is_object(‪$GLOBALS['TSFE'])) {
            $fileReferenceData = ‪$GLOBALS['TSFE']->sys_page->checkRecord('sys_file_reference', $uid);
        } else {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file_reference');
            $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));
            $fileReferenceData = $queryBuilder->select('*')
                ->from('sys_file_reference')
                ->where(
                    $queryBuilder->expr()->eq(
                        'uid',
                        $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                    )
                )
                ->execute()
                ->fetch();
        }
        return $fileReferenceData;
    }
 
    protected function ‪getFileIndexRepository()
    {
        return ‪FileIndexRepository::getInstance();
    }
 
    protected function ‪getProcessedFileRepository()
    {
        return GeneralUtility::makeInstance(ProcessedFileRepository::class);
    }
 
    protected function ‪getIndexer(‪ResourceStorage $storage)
    {
        return GeneralUtility::makeInstance(Index\Indexer::class, $storage);
    }
}