9.5/_storage_repository_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 Psr\Log\LoggerAwareInterface;

use Psr\Log\LoggerAwareTrait;

use ‪TYPO3\CMS\Core\Configuration\FlexForm\FlexFormTools;

use ‪TYPO3\CMS\Core\Core\Environment;

use ‪TYPO3\CMS\Core\Database\ConnectionPool;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\FrontendRestrictionContainer;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;


class ‪StorageRepository extends ‪AbstractRepository implements LoggerAwareInterface

{

    use LoggerAwareTrait;


    protected ‪$storageRowCache;


    protected ‪$objectType = ResourceStorage::class;


    protected ‪$table = 'sys_file_storage';


    protected ‪$typeField = 'driver';


    protected ‪$driverField = 'driver';


    public function ‪findByUid($uid)

    {

        $this->‪initializeLocalCache();

        if (isset($this->storageRowCache[$uid])) {

            return $this->factory->getStorageObject($uid, $this->storageRowCache[$uid]);

        }

        return null;

    }


    public function ‪fetchRowByUid(int $uid): array

    {

        $this->‪initializeLocalCache();

        if (!isset($this->storageRowCache[$uid])) {

            throw new \InvalidArgumentException(sprintf('No storage found with uid "%d".', $uid), 1599235454);

        }


        return $this->storageRowCache[$uid];

    }


    protected function ‪initializeLocalCache()

    {

        if ($this->storageRowCache === null) {

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)

                ->getQueryBuilderForTable($this->table);


            if ($this->‪getEnvironmentMode() === 'FE') {

                $queryBuilder->setRestrictions(GeneralUtility::makeInstance(FrontendRestrictionContainer::class));

            }


            $result = $queryBuilder

                ->select('*')

                ->from($this->table)

                ->orderBy('name')

                ->execute();


            $this->storageRowCache = [];

            while ($row = $result->fetch()) {

                if (!empty($row['uid'])) {

                    $this->storageRowCache[$row['uid']] = $row;

                }

            }


            // if no storage is created before or the user has not access to a storage

            // $this->storageRowCache would have the value array()

            // so check if there is any record. If no record is found, create the fileadmin/ storage

            // selecting just one row is enough


            if ($this->storageRowCache === []) {

                $connection = GeneralUtility::makeInstance(ConnectionPool::class)

                    ->getConnectionForTable($this->table);


                $storageObjectsCount = $connection->count('uid', $this->table, []);


                if ($storageObjectsCount === 0) {

                    if ($this->‪createLocalStorage(

                        'fileadmin/ (auto-created)',

                        ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'],

                        'relative',

                        'This is the local fileadmin/ directory. This storage mount has been created automatically by TYPO3.',

                        true

                    ) > 0) {

                        // reset to null to force reloading of storages

                        $this->storageRowCache = null;

                        // call self for initialize Cache

                        $this->‪initializeLocalCache();

                    }

                }

            }

        }

    }


    public function ‪findByStorageType($storageType)

    {

        $this->‪initializeLocalCache();


        $driverRegistry = GeneralUtility::makeInstance(Driver\DriverRegistry::class);


        $storageObjects = [];

        foreach ($this->storageRowCache as $storageRow) {

            if ($storageRow['driver'] !== $storageType) {

                continue;

            }

            if ($driverRegistry->driverExists($storageRow['driver'])) {

                $storageObjects[] = $this->factory->getStorageObject($storageRow['uid'], $storageRow);

            } else {

                $this->logger->warning(

                    sprintf('Could not instantiate storage "%s" because of missing driver.', [$storageRow['name']]),

                    $storageRow

                );

            }

        }

        return $storageObjects;

    }


    public function ‪findAll()

    {

        $this->‪initializeLocalCache();


        $driverRegistry = GeneralUtility::makeInstance(Driver\DriverRegistry::class);


        $storageObjects = [];

        foreach ($this->storageRowCache as $storageRow) {

            if ($driverRegistry->driverExists($storageRow['driver'])) {

                $storageObjects[] = $this->factory->getStorageObject($storageRow['uid'], $storageRow);

            } else {

                $this->logger->warning(

                    sprintf('Could not instantiate storage "%s" because of missing driver.', [$storageRow['name']]),

                    $storageRow

                );

            }

        }

        return $storageObjects;

    }


    public function ‪createLocalStorage($name, $basePath, $pathType, $description = '', $default = false)

    {

        $caseSensitive = $this->‪testCaseSensitivity($pathType === 'relative' ? ‪Environment::getPublicPath() . '/' . $basePath : $basePath);

        // create the FlexForm for the driver configuration

        $flexFormData = [

            'data' => [

                'sDEF' => [

                    'lDEF' => [

                        'basePath' => ['vDEF' => rtrim($basePath, '/') . '/'],

                        'pathType' => ['vDEF' => $pathType],

                        'caseSensitive' => ['vDEF' => $caseSensitive]

                    ]

                ]

            ]

        ];


        $flexObj = GeneralUtility::makeInstance(FlexFormTools::class);

        $flexFormXml = $flexObj->flexArray2Xml($flexFormData, true);


        // create the record

        $field_values = [

            'pid' => 0,

            'tstamp' => ‪$GLOBALS['EXEC_TIME'],

            'crdate' => ‪$GLOBALS['EXEC_TIME'],

            'name' => $name,

            'description' => $description,

            'driver' => 'Local',

            'configuration' => $flexFormXml,

            'is_online' => 1,

            'is_browsable' => 1,

            'is_public' => 1,

            'is_writable' => 1,

            'is_default' => $default ? 1 : 0

        ];


        $dbConnection = GeneralUtility::makeInstance(ConnectionPool::class)

            ->getConnectionForTable($this->table);

        $dbConnection->insert($this->table, $field_values);


        // Flush local resourceStorage cache so the storage can be accessed during the same request right away

        $this->storageRowCache = null;


        return (int)$dbConnection->lastInsertId($this->table);

    }


    protected function ‪createDomainObject(array $databaseRow)

    {

        return $this->factory->getStorageObject($databaseRow['uid'], $databaseRow);

    }


    protected function ‪testCaseSensitivity($absolutePath)

    {

        $caseSensitive = true;

        $path = rtrim($absolutePath, '/') . '/aAbB';

        $testFileExists = @file_exists($path);


        // create test file

        if (!$testFileExists) {

            touch($path);

        }


        // do the actual sensitivity check

        if (@file_exists(strtoupper($path)) && @file_exists(strtolower($path))) {

            $caseSensitive = false;

        }


        // clean filesystem

        if (!$testFileExists) {

            unlink($path);

        }


        return $caseSensitive;

    }

}