9.5/_file_index_repository_8php_source.html

<?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]);

    }

}