ResourceFactory.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Resource;
 
use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Collection\AbstractRecordCollection;
use ‪TYPO3\CMS\Core\Collection\CollectionInterface;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\Http\ApplicationType;
use ‪TYPO3\CMS\Core\Resource\Collection\FileCollectionRegistry;
use ‪TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException;
use ‪TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use ‪TYPO3\CMS\Core\Resource\Index\FileIndexRepository;
use ‪TYPO3\CMS\Core\Service\FlexFormService;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
class ‪ResourceFactory implements ‪SingletonInterface
{
    protected ‪$collectionInstances = [];
 
    protected ‪$fileInstances = [];
 
    protected array ‪$fileReferenceInstances = [];
 
    public function ‪__construct(
        protected readonly ‪StorageRepository $storageRepository,
    ) {}
 
    public function ‪getDefaultStorage()
    {
        return $this->storageRepository->getDefaultStorage();
    }
 
    public function ‪getStorageObject(‪$uid, array $recordData = [], &$fileIdentifier = null)
    {
        return $this->storageRepository->getStorageObject(‪$uid, $recordData, $fileIdentifier);
    }
 
    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 (!isset($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, ‪Connection::PARAM_INT)
                        )
                    )
                    ->executeQuery()
                    ->fetchAssociative();
                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(FileCollectionRegistry::class);
 
        $class = $registry->getFileCollectionClass($collectionData['type']);
 
        return $class::create($collectionData);
    }
 
    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 FileDoesNotExistException('No file found for given UID: ' . ‪$uid, 1317178604);
                }
            }
            $this->fileInstances[‪$uid] = $this->‪createFileObject($fileData);
        }
        return $this->fileInstances[‪$uid];
    }
 
    public function ‪getFileObjectFromCombinedIdentifier(‪$identifier)
    {
        if (!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 = (int)$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];
        }
        return $this->storageRepository->getStorageObject($storageUid, [], $fileIdentifier)
            ->getFileByIdentifier($fileIdentifier);
    }
 
    public function ‪getFileObjectByStorageAndIdentifier($storage, &$fileIdentifier)
    {
        if (!($storage instanceof ResourceStorage)) {
            $storage = $this->storageRepository->getStorageObject($storage, [], $fileIdentifier);
        }
        return $storage->getFileByIdentifier($fileIdentifier);
    }
 
    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() . '/', '', (string)$input);
 
        if (str_starts_with($input, 'file:')) {
            $input = substr($input, 5);
            return $this->‪retrieveFileOrFolderObject($input);
        }
        if (‪MathUtility::canBeInterpretedAsInteger($input)) {
            return $this->‪getFileObject((int)$input);
        }
        if (strpos($input, ':') > 0) {
            [$prefix] = explode(':', $input);
            if (‪MathUtility::canBeInterpretedAsInteger($prefix)) {
                // path or folder in a valid storageUID
                return $this->‪getObjectFromCombinedIdentifier($input);
            }
            if ($prefix === 'EXT') {
                $absoluteFilePath = GeneralUtility::getFileAbsFileName($input);
                if (empty($absoluteFilePath)) {
                    return null;
                }
                if (str_starts_with($absoluteFilePath, ‪Environment::getPublicPath())) {
                    $relativePath = ‪PathUtility::getRelativePath(‪Environment::getPublicPath() . '/', ‪PathUtility::dirname($absoluteFilePath)) . ‪PathUtility::basename($absoluteFilePath);
                } else {
                    try {
                        $relativePath = ‪PathUtility::getPublicResourceWebPath($input);
                    } catch (\Throwable $e) {
                        throw new ResourceDoesNotExistException(sprintf('Tried to access a private resource file "%s" from fallback compatibility storage. This storage only handles public files.', $input), 1633777536);
                    }
                }
 
                return $this->‪getFileObjectFromCombinedIdentifier($relativePath);
            }
            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 = (int)$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 (str_starts_with($folderIdentifier, ‪Environment::getPublicPath() . '/')) {
                $folderIdentifier = ‪PathUtility::stripPathSitePrefix($parts[0]);
            }
        }
        return $this->storageRepository->getStorageObject($storageUid, [], $folderIdentifier)->getFolder($folderIdentifier);
    }
 
    public function ‪getStorageObjectFromCombinedIdentifier(‪$identifier)
    {
        [$storageId, $objectIdentifier] = array_pad(‪GeneralUtility::trimExplode(':', ‪$identifier), 2, null);
        if (!‪MathUtility::canBeInterpretedAsInteger($storageId) && $objectIdentifier === null) {
            return $this->storageRepository->findByUid(0);
        }
        return $this->storageRepository->findByUid((int)$storageId);
    }
 
    public function ‪getObjectFromCombinedIdentifier(‪$identifier)
    {
        [$storageId, $objectIdentifier] = array_pad(‪GeneralUtility::trimExplode(':', ‪$identifier), 2, null);
        if (!‪MathUtility::canBeInterpretedAsInteger($storageId) && $objectIdentifier === null) {
            $objectIdentifier = $storageId;
            $storageId = 0;
        }
        if (‪MathUtility::canBeInterpretedAsInteger($storageId)) {
            $storage = $this->storageRepository->findByUid($storageId);
            if ($storage->hasFile($objectIdentifier)) {
                return $storage->getFile($objectIdentifier);
            }
            if ($storage->hasFolder($objectIdentifier)) {
                return $storage->getFolder($objectIdentifier);
            }
        }
        throw new 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->storageRepository->findByUid((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(int ‪$uid, array $fileReferenceData = [], bool $raw = false): FileReference
    {
        if (!($this->fileReferenceInstances[‪$uid] ?? false)) {
            // Fetches data in case $fileData is empty
            if (empty($fileReferenceData)) {
                $fileReferenceData = $this->‪getFileReferenceData($uid, $raw);
                if (!is_array($fileReferenceData)) {
                    throw new 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): FileReference
    {
        return GeneralUtility::makeInstance(FileReference::class, $fileReferenceData);
    }
 
    protected function ‪getFileReferenceData(int ‪$uid, bool $raw = false): ?array
    {
        $request = ‪$GLOBALS['TYPO3_REQUEST'] ?? null;
        if (!$raw
            && $request instanceof ServerRequestInterface
            && ‪ApplicationType::fromRequest($request)->isBackend()
        ) {
            $fileReferenceData = BackendUtility::getRecordWSOL('sys_file_reference', ‪$uid);
        } elseif (!$raw
            && $request instanceof ServerRequestInterface
            && ‪ApplicationType::fromRequest($request)->isFrontend()
        ) {
            $fileReferenceData = GeneralUtility::makeInstance(PageRepository::class)->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, ‪Connection::PARAM_INT)
                    )
                )
                ->executeQuery()
                ->fetchAssociative();
        }
        return $fileReferenceData;
    }
 
    protected function ‪getFileIndexRepository()
    {
        return GeneralUtility::makeInstance(FileIndexRepository::class);
    }
}