9.5/_resource_factory_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\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);

    }

}