MetaDataRepository.php

Go to the documentation of this file.

<?php
 
namespace ‪TYPO3\CMS\Core\Resource\Index;
 
/*
 * 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 Doctrine\DBAL\Platforms\SQLServerPlatform;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\RootLevelRestriction;
use ‪TYPO3\CMS\Core\Resource\Exception\InvalidUidException;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Type\File as ‪FileType;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
 
class ‪MetaDataRepository implements ‪SingletonInterface
{
    protected ‪$tableName = 'sys_file_metadata';
 
    protected ‪$tableFields = [];
 
    public function ‪findByFile(‪File $file)
    {
        $record = $this->‪findByFileUid($file->‪getUid());
 
        // It could be possible that the meta information is freshly
        // created and inserted into the database. If this is the case
        // we have to take care about correct meta information for width and
        // height in case of an image.
        if (!empty($record['newlyCreated'])) {
            if ($file->‪getType() === ‪File::FILETYPE_IMAGE && $file->‪getStorage()->‪getDriverType() === 'Local') {
                $fileNameAndPath = $file->‪getForLocalProcessing(false);
 
                $imageInfo = GeneralUtility::makeInstance(‪FileType\ImageInfo::class, $fileNameAndPath);
 
                $additionalMetaInformation = [
                    'width' => $imageInfo->getWidth(),
                    'height' => $imageInfo->getHeight(),
                ];
 
                $this->‪update($file->‪getUid(), $additionalMetaInformation);
            }
            $record = $this->‪findByFileUid($file->‪getUid());
        }
 
        return $record;
    }
 
    public function ‪findByFileUid($uid)
    {
        $uid = (int)$uid;
        if ($uid <= 0) {
            throw new ‪InvalidUidException('Metadata can only be retrieved for indexed files. UID: "' . $uid . '"', 1381590731);
        }
 
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->tableName);
 
        $queryBuilder->getRestrictions()->add(GeneralUtility::makeInstance(RootLevelRestriction::class));
 
        $record = $queryBuilder
            ->select('*')
            ->from($this->tableName)
            ->where(
                $queryBuilder->expr()->eq('file', $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)),
                $queryBuilder->expr()->in('sys_language_uid', $queryBuilder->createNamedParameter([0, -1], Connection::PARAM_INT_ARRAY))
            )
            ->execute()
            ->fetch();
 
        if (empty($record)) {
            $record = $this->‪createMetaDataRecord($uid);
        }
 
        $passedData = new \ArrayObject($record);
 
        $this->‪emitRecordPostRetrievalSignal($passedData);
        return $passedData->getArrayCopy();
    }
 
    public function ‪createMetaDataRecord($fileUid, array $additionalFields = [])
    {
        $emptyRecord = [
            'file' => (int)$fileUid,
            'pid' => 0,
            'crdate' => ‪$GLOBALS['EXEC_TIME'],
            'tstamp' => ‪$GLOBALS['EXEC_TIME'],
            'cruser_id' => isset(‪$GLOBALS['BE_USER']->user['uid']) ? (int)‪$GLOBALS['BE_USER']->user['uid'] : 0,
            'l10n_diffsource' => ''
        ];
        $emptyRecord = array_merge($emptyRecord, $additionalFields);
 
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->tableName);
        $connection->insert(
            $this->tableName,
            $emptyRecord,
            ['l10n_diffsource' => ‪Connection::PARAM_LOB]
        );
 
        $record = $emptyRecord;
        $record['uid'] = $connection->lastInsertId($this->tableName);
        $record['newlyCreated'] = true;
 
        $this->‪emitRecordCreatedSignal($record);
 
        return $record;
    }
 
    public function ‪update($fileUid, array $data)
    {
        if (empty($this->tableFields)) {
            $this->tableFields = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getConnectionForTable($this->tableName)
                ->getSchemaManager()
                ->listTableColumns($this->tableName);
        }
        $updateRow = array_intersect_key($data, $this->tableFields);
        if (array_key_exists('uid', $updateRow)) {
            unset($updateRow['uid']);
        }
        $row = $this->‪findByFileUid($fileUid);
        if (!empty($updateRow)) {
            $updateRow['tstamp'] = time();
            $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->tableName);
            $types = [];
            if ($connection->getDatabasePlatform() instanceof SQLServerPlatform) {
                // mssql needs to set proper PARAM_LOB and others to update fields
                $tableDetails = $connection->getSchemaManager()->listTableDetails($this->tableName);
                foreach ($updateRow as $columnName => $columnValue) {
                    $types[$columnName] = $tableDetails->getColumn($columnName)->getType()->getBindingType();
                }
            }
            $connection->update(
                $this->tableName,
                $updateRow,
                [
                        'uid' => (int)$row['uid']
                    ],
                $types
            );
 
            $this->‪emitRecordUpdatedSignal(array_merge($row, $updateRow));
        }
    }
 
    public function ‪removeByFileUid($fileUid)
    {
        GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable($this->tableName)
            ->delete(
                $this->tableName,
                [
                    'file' => (int)$fileUid
                ]
            );
        $this->‪emitRecordDeletedSignal($fileUid);
    }
 
    protected function ‪getSignalSlotDispatcher()
    {
        return $this->‪getObjectManager()->‪get(Dispatcher::class);
    }
 
    protected function ‪getObjectManager()
    {
        return GeneralUtility::makeInstance(ObjectManager::class);
    }
 
    protected function ‪emitRecordPostRetrievalSignal(\ArrayObject $data)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(self::class, 'recordPostRetrieval', [$data]);
    }
 
    protected function ‪emitRecordUpdatedSignal(array $data)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(self::class, 'recordUpdated', [$data]);
    }
 
    protected function ‪emitRecordCreatedSignal(array $data)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(self::class, 'recordCreated', [$data]);
    }
 
    protected function ‪emitRecordDeletedSignal($fileUid)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(self::class, 'recordDeleted', [$fileUid]);
    }
 
    public static function ‪getInstance()
    {
        return GeneralUtility::makeInstance(self::class);
    }
}