FileIndexRepository.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 ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\ReferenceIndex;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\FileInterface;
use ‪TYPO3\CMS\Core\Resource\Folder;
use ‪TYPO3\CMS\Core\Resource\ResourceFactory;
use ‪TYPO3\CMS\Core\Resource\ResourceStorage;
use ‪TYPO3\CMS\Core\Resource\Search\FileSearchDemand;
use ‪TYPO3\CMS\Core\Resource\Search\FileSearchQuery;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
 
class ‪FileIndexRepository implements ‪SingletonInterface
{
    protected ‪$table = 'sys_file';
 
    protected ‪$fields = [
        'uid', 'pid', 'missing', 'type', 'storage', 'identifier', 'identifier_hash', 'extension',
        'mime_type', 'name', 'sha1', 'size', 'creation_date', 'modification_date', 'folder_hash'
    ];
 
    protected function ‪getResourceFactory()
    {
        return ‪ResourceFactory::getInstance();
    }
 
    public static function ‪getInstance()
    {
        return GeneralUtility::makeInstance(self::class);
    }
 
    public function ‪findOneByCombinedIdentifier($combinedIdentifier)
    {
        list($storageUid, $identifier) = GeneralUtility::trimExplode(':', $combinedIdentifier, false, 2);
        return $this->‪findOneByStorageUidAndIdentifier($storageUid, $identifier);
    }
 
    public function ‪findOneByUid($fileUid)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($this->table);
 
        $row = $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid, \PDO::PARAM_INT))
            )
            ->execute()
            ->fetch();
 
        return is_array($row) ? $row : false;
    }
 
    public function ‪findOneByStorageUidAndIdentifier($storageUid, $identifier)
    {
        $identifierHash = $this->‪getResourceFactory()->‪getStorageObject($storageUid)->‪hashFileIdentifier($identifier);
        return $this->‪findOneByStorageUidAndIdentifierHash($storageUid, $identifierHash);
    }
 
    public function ‪findOneByStorageUidAndIdentifierHash($storageUid, $identifierHash)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($this->table);
 
        $row = $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->eq('storage', $queryBuilder->createNamedParameter($storageUid, \PDO::PARAM_INT)),
                $queryBuilder->expr()->eq('identifier_hash', $queryBuilder->createNamedParameter($identifierHash))
            )
            ->execute()
            ->fetch();
 
        return is_array($row) ? $row : false;
    }
 
    public function ‪findOneByFileObject(‪FileInterface $fileObject)
    {
        $storageUid = $fileObject->‪getStorage()->‪getUid();
        $identifierHash = $fileObject->‪getHashedIdentifier();
        return $this->‪findOneByStorageUidAndIdentifierHash($storageUid, $identifierHash);
    }
 
    public function ‪findByContentHash($hash)
    {
        if (!preg_match('/^[0-9a-f]{40}$/i', $hash)) {
            return [];
        }
 
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($this->table);
 
        $resultRows = $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->eq('sha1', $queryBuilder->createNamedParameter($hash, \PDO::PARAM_STR))
            )
            ->execute()
            ->fetchAll();
 
        return $resultRows;
    }
 
    public function ‪findByFolder(‪Folder $folder)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($this->table);
 
        $result = $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->eq(
                    'folder_hash',
                    $queryBuilder->createNamedParameter($folder->‪getHashedIdentifier(), \PDO::PARAM_STR)
                ),
                $queryBuilder->expr()->eq(
                    'storage',
                    $queryBuilder->createNamedParameter($folder->‪getStorage()->‪getUid(), \PDO::PARAM_INT)
                )
            )
            ->execute();
 
        $resultRows = [];
        while ($row = $result->fetch()) {
            $resultRows[$row['identifier']] = $row;
        }
 
        return $resultRows;
    }
 
    public function ‪findByFolders(array $folders, $includeMissing = true, $fileName = null)
    {
        $storageUids = [];
        $folderIdentifiers = [];
 
        foreach ($folders as $folder) {
            if (!$folder instanceof ‪Folder) {
                continue;
            }
 
            $storageUids[] = (int)$folder->getStorage()->getUid();
            $folderIdentifiers[] = $folder->getHashedIdentifier();
        }
 
        $storageUids = array_unique($storageUids);
        $folderIdentifiers = array_unique($folderIdentifiers);
 
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);
 
        $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->in(
                    'folder_hash',
                    $queryBuilder->createNamedParameter($folderIdentifiers, Connection::PARAM_STR_ARRAY)
                ),
                $queryBuilder->expr()->in(
                    'storage',
                    $queryBuilder->createNamedParameter($storageUids, Connection::PARAM_INT_ARRAY)
                )
            );
 
        if (isset($fileName)) {
            $nameParts = str_getcsv($fileName, ' ');
            foreach ($nameParts as $part) {
                $part = trim($part);
                if ($part !== '') {
                    $queryBuilder->andWhere(
                        $queryBuilder->expr()->like(
                            'name',
                            $queryBuilder->createNamedParameter(
                                '%' . $queryBuilder->escapeLikeWildcards($part) . '%',
                                \PDO::PARAM_STR
                            )
                        )
                    );
                }
            }
        }
 
        if (!$includeMissing) {
            $queryBuilder->andWhere($queryBuilder->expr()->eq('missing', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)));
        }
 
        $result = $queryBuilder->execute();
 
        $fileRecords = [];
        while ($fileRecord = $result->fetch()) {
            $fileRecords[$fileRecord['identifier']] = $fileRecord;
        }
 
        return $fileRecords;
    }
 
    public function ‪add(‪File $file)
    {
        if ($this->‪hasIndexRecord($file)) {
            $this->‪update($file);
            if ($file->‪_getPropertyRaw('uid') === null) {
                $file->‪updateProperties($this->‪findOneByFileObject($file));
            }
        } else {
            $file->‪updateProperties(['uid' => $this->‪insertRecord($file->‪getProperties())]);
        }
    }
 
    public function ‪addRaw(array $data)
    {
        $data['uid'] = $this->‪insertRecord($data);
        return $data;
    }
 
    protected function ‪insertRecord(array $data)
    {
        $data = array_intersect_key($data, array_flip($this->fields));
        $data['tstamp'] = time();
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);
        $connection->insert(
            $this->table,
            $data
        );
        $data['uid'] = $connection->lastInsertId($this->table);
        $this->‪updateRefIndex($data['uid']);
        $this->‪emitRecordCreatedSignal($data);
        return $data['uid'];
    }
 
    public function ‪hasIndexRecord(‪File $file)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);
 
        if ((int)$file->‪_getPropertyRaw('uid') > 0) {
            $constraints = [
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($file->‪getUid(), \PDO::PARAM_INT))
            ];
        } else {
            $constraints = [
                $queryBuilder->expr()->eq(
                    'storage',
                    $queryBuilder->createNamedParameter($file->‪getStorage()->‪getUid(), \PDO::PARAM_INT)
                ),
                $queryBuilder->expr()->eq(
                    'identifier',
                    $queryBuilder->createNamedParameter($file->‪_getPropertyRaw('identifier'), \PDO::PARAM_STR)
                )
            ];
        }
 
        $count = $queryBuilder
            ->count('uid')
            ->from($this->table)
            ->where(...$constraints)
            ->execute()
            ->fetchColumn(0);
 
        return (bool)$count;
    }
 
    public function ‪update(‪File $file)
    {
        $updatedProperties = array_intersect($this->fields, $file->‪getUpdatedProperties());
        $updateRow = [];
        foreach ($updatedProperties as $key) {
            $updateRow[$key] = $file->‪getProperty($key);
        }
        if (!empty($updateRow)) {
            if ((int)$file->‪_getPropertyRaw('uid') > 0) {
                $constraints = ['uid' => (int)$file->‪getUid()];
            } else {
                $constraints = [
                    'storage' => (int)$file->‪getStorage()->‪getUid(),
                    'identifier' => $file->‪_getPropertyRaw('identifier')
                ];
            }
 
            $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);
            $updateRow['tstamp'] = time();
 
            $connection->update(
                $this->table,
                $updateRow,
                $constraints
            );
 
            $this->‪updateRefIndex($file->‪getUid());
            $this->‪emitRecordUpdatedSignal(array_intersect_key($file->‪getProperties(), array_flip($this->fields)));
        }
    }
 
    public function ‪findInStorageWithIndexOutstanding(‪ResourceStorage $storage, $limit = -1)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);
 
        if ((int)$limit > 0) {
            $queryBuilder->setMaxResults((int)$limit);
        }
 
        $rows = $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->gt('tstamp', $queryBuilder->quoteIdentifier('last_indexed')),
                $queryBuilder->expr()->eq('storage', $queryBuilder->createNamedParameter($storage->‪getUid(), \PDO::PARAM_INT))
            )
            ->orderBy('tstamp', 'ASC')
            ->execute()
            ->fetchAll();
 
        return $rows;
    }
 
    public function ‪findInStorageAndNotInUidList(‪ResourceStorage $storage, array $uidList)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);
 
        $queryBuilder
            ->select(...$this->fields)
            ->from($this->table)
            ->where(
                $queryBuilder->expr()->eq(
                    'storage',
                    $queryBuilder->createNamedParameter($storage->‪getUid(), \PDO::PARAM_INT)
                )
            );
 
        if (!empty($uidList)) {
            $queryBuilder->andWhere(
                $queryBuilder->expr()->notIn(
                    'uid',
                    array_map('intval', $uidList)
                )
            );
        }
 
        $rows = $queryBuilder->execute()->fetchAll();
 
        return $rows;
    }
 
    public function ‪updateIndexingTime($fileUid)
    {
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);
        $connection->update(
            $this->table,
            [
                'last_indexed' => time()
            ],
            [
                'uid' => (int)$fileUid
            ]
        );
    }
 
    public function ‪markFileAsMissing($fileUid)
    {
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);
        $connection->update(
            $this->table,
            [
                'missing' => 1
            ],
            [
                'uid' => (int)$fileUid
            ]
        );
        $this->‪emitRecordMarkedAsMissingSignal($fileUid);
    }
 
    public function remove($fileUid)
    {
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);
        $connection->delete(
            $this->table,
            [
                'uid' => (int)$fileUid
            ]
        );
        $this->‪updateRefIndex($fileUid);
        $this->‪emitRecordDeletedSignal($fileUid);
    }
 
    public function ‪updateRefIndex($id)
    {
        $refIndexObj = GeneralUtility::makeInstance(ReferenceIndex::class);
        $refIndexObj->enableRuntimeCache();
        $refIndexObj->updateRefIndexTable($this->table, $id);
    }
 
    public function ‪findBySearchWordInMetaData($searchWord)
    {
        trigger_error(__METHOD__ . ' is deprecated. Use FileSearchQuery instead', \E_USER_DEPRECATED);
        $searchDemand = ‪FileSearchDemand::createForSearchTerm($searchWord);
        $searchQuery = ‪FileSearchQuery::createForSearchDemand($searchDemand);
        $result = $searchQuery->execute();
        $fileRecords = [];
        while ($fileRecord = $result->fetch()) {
            $fileRecords[$fileRecord['identifier']] = $fileRecord;
        }
 
        return $fileRecords;
    }
 
    protected function ‪getSignalSlotDispatcher()
    {
        return $this->‪getObjectManager()->‪get(Dispatcher::class);
    }
 
    protected function ‪getObjectManager()
    {
        return GeneralUtility::makeInstance(ObjectManager::class);
    }
 
    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]);
    }
 
    protected function ‪emitRecordMarkedAsMissingSignal($fileUid)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(self::class, 'recordMarkedAsMissing', [$fileUid]);
    }
}