9.5/_processed_file_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\Database\Connection;

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

use ‪TYPO3\CMS\Core\Imaging\ImageManipulation\Area;

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


class ‪ProcessedFileRepository extends ‪AbstractRepository implements LoggerAwareInterface

{

    use LoggerAwareTrait;


    protected ‪$objectType = ProcessedFile::class;


    protected ‪$table = 'sys_file_processedfile';


    protected ‪$tableColumns = [];


    public function ‪__construct()

    {

        parent::__construct();

    }


    public function ‪createNewProcessedFileObject(‪FileInterface $originalFile, $taskType, array $configuration)

    {

        return GeneralUtility::makeInstance(

            $this->objectType,

            $originalFile,

            $taskType,

            $configuration

        );

    }


    protected function ‪createDomainObject(array $databaseRow)

    {

        $originalFile = $this->factory->getFileObject((int)$databaseRow['original']);

        $originalFile->setStorage($this->factory->getStorageObject($originalFile->‪getProperty('storage')));

        $taskType = $databaseRow['task_type'];

        // Allow deserialization of Area class, since Area objects get serialized in configuration

        // TODO: This should be changed to json encode and decode at some point

        $configuration = unserialize(

            $databaseRow['configuration'],

            [

                'allowed_classes' => [

                    Area::class,

                ],

            ]

        );


        return GeneralUtility::makeInstance(

            $this->objectType,

            $originalFile,

            $taskType,

            $configuration,

            $databaseRow

        );

    }


    public function ‪findByStorageAndIdentifier(‪ResourceStorage $storage, $identifier)

    {

        $processedFileObject = null;

        if ($storage->‪hasFile($identifier)) {

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);

            $databaseRow = $queryBuilder

                ->select('*')

                ->from($this->table)

                ->where(

                    $queryBuilder->expr()->eq(

                        'storage',

                        $queryBuilder->createNamedParameter($storage->‪getUid(), \PDO::PARAM_INT)

                    ),

                    $queryBuilder->expr()->eq(

                        'identifier',

                        $queryBuilder->createNamedParameter($identifier, \PDO::PARAM_STR)

                    )

                )

                ->execute()

                ->fetch();


            if ($databaseRow) {

                $processedFileObject = $this->‪createDomainObject($databaseRow);

            }

        }

        return $processedFileObject;

    }


    public function ‪countByStorage(‪ResourceStorage $storage): int

    {

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

            ->getQueryBuilderForTable($this->table);

        return (int)$queryBuilder

            ->count('uid')

            ->from($this->table)

            ->where(

                $queryBuilder->expr()->eq(

                    'storage',

                    $queryBuilder->createNamedParameter($storage->‪getUid(), \PDO::PARAM_INT)

                )

            )

            ->execute()

            ->fetchColumn(0);

    }


    public function ‪add($processedFile)

    {

        if ($processedFile->isPersisted()) {

            $this->‪update($processedFile);

        } else {

            $insertFields = $processedFile->toArray();

            $insertFields['crdate'] = $insertFields['tstamp'] = time();

            $insertFields = $this->‪cleanUnavailableColumns($insertFields);


            $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);


            $connection->insert(

                $this->table,

                $insertFields,

                ['configuration' => ‪Connection::PARAM_LOB]

            );


            $uid = $connection->lastInsertId($this->table);

            $processedFile->updateProperties(['uid' => $uid]);

        }

    }


    public function ‪update($processedFile)

    {

        if ($processedFile->isPersisted()) {

            $uid = (int)$processedFile->getUid();

            $updateFields = $this->‪cleanUnavailableColumns($processedFile->toArray());

            $updateFields['tstamp'] = time();


            $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($this->table);

            $connection->update(

                $this->table,

                $updateFields,

                [

                    'uid' => (int)$uid

                ],

                ['configuration' => ‪Connection::PARAM_LOB]

            );

        }

    }


    public function ‪findOneByOriginalFileAndTaskTypeAndConfiguration(‪FileInterface $file, $taskType, array $configuration)

    {

        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);


        $databaseRow = $queryBuilder

            ->select('*')

            ->from($this->table)

            ->where(

                $queryBuilder->expr()->eq(

                    'original',

                    $queryBuilder->createNamedParameter($file->getUid(), \PDO::PARAM_INT)

                ),

                $queryBuilder->expr()->eq('task_type', $queryBuilder->createNamedParameter($taskType, \PDO::PARAM_STR)),

                $queryBuilder->expr()->eq(

                    'configurationsha1',

                    $queryBuilder->createNamedParameter(sha1(serialize($configuration)), \PDO::PARAM_STR)

                )

            )

            ->execute()

            ->fetch();


        if (is_array($databaseRow)) {

            $processedFile = $this->‪createDomainObject($databaseRow);

        } else {

            $processedFile = $this->‪createNewProcessedFileObject($file, $taskType, $configuration);

        }

        return $processedFile;

    }


    public function ‪findAllByOriginalFile(‪FileInterface $file)

    {

        if (!$file instanceof ‪File) {

            throw new \InvalidArgumentException('Parameter is no File object but got type "'

                . (is_object($file) ? get_class($file) : gettype($file)) . '"', 1382006142);

        }


        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($this->table);

        $result = $queryBuilder

            ->select('*')

            ->from($this->table)

            ->where(

                $queryBuilder->expr()->eq(

                    'original',

                    $queryBuilder->createNamedParameter($file->getUid(), \PDO::PARAM_INT)

                )

            )

            ->execute();


        $itemList = [];

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

            $itemList[] = $this->‪createDomainObject($row);

        }

        return $itemList;

    }


    public function ‪removeAll($storageUid = null)

    {

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

            ->getQueryBuilderForTable($this->table);

        $where = [

            $queryBuilder->expr()->neq('identifier', $queryBuilder->createNamedParameter('', \PDO::PARAM_STR))

        ];

        if ($storageUid !== null) {

            $where[] = $queryBuilder->expr()->eq(

                'storage',

                $queryBuilder->createNamedParameter($storageUid, \PDO::PARAM_INT)

            );

        }

        $result = $queryBuilder

            ->select('*')

            ->from($this->table)

            ->where(...$where)

            ->execute();


        $errorCount = 0;


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

            if ($storageUid && (int)$storageUid !== (int)$row['storage']) {

                continue;

            }

            try {

                $file = $this->‪createDomainObject($row);

                $file->‪getStorage()->‪setEvaluatePermissions(false);

                $file->‪delete(true);

            } catch (\‪Exception $e) {

                $this->logger->error(

                    'Failed to delete file "' . $row['identifier'] . '" in storage uid ' . $row['storage'] . '.',

                    [

                        'exception' => $e

                    ]

                );

                ++$errorCount;

            }

        }


        if ($storageUid === null) {

            // Truncate entire table if not restricted to specific storage

            GeneralUtility::makeInstance(ConnectionPool::class)

                ->getConnectionForTable($this->table)

                ->truncate($this->table);

        } else {

            // else remove db rows of this storage only

            GeneralUtility::makeInstance(ConnectionPool::class)

                ->getConnectionForTable($this->table)

                ->delete($this->table, ['storage' => $storageUid], [\PDO::PARAM_INT]);

        }


        return $errorCount;

    }


    protected function ‪cleanUnavailableColumns(array $data)

    {

        // As determining the table columns is a costly operation this is done only once during runtime and cached then

        if (empty($this->tableColumns[$this->table])) {

            $this->tableColumns[‪$this->table] = GeneralUtility::makeInstance(ConnectionPool::class)

                ->getConnectionForTable($this->table)

                ->getSchemaManager()

                ->listTableColumns($this->table);

        }


        return array_intersect_key($data, $this->tableColumns[$this->table]);

    }

}