Fab\Media\Hook\DataHandlerHook

Complexity

Total Complexity

40

Size/Duplication

Total Lines	311
Duplicated Lines	13.18 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	processDatamap_beforeStart()	22	32	5
B	processDatamap_afterAllOperations()	19	40	6
A	initializeFileRegister()	0	8	2
A	registerFilesToKeepTrack()	0	23	5
A	getRegisteredFiles()	0	5	1
A	getFileToProcess()	0	9	1
A	addBeforeDataHandlerProcessFileIdentifiers()	0	4	1
A	addAfterDataHandlerProcessFileIdentifiers()	0	4	1
B	lookForFiles()	0	21	7
A	isFileReference()	0	4	1
A	isSoftReferenceLink()	0	4	2
A	isSoftReferenceImage()	0	4	2
A	findFileByFileReference()	0	16	2
A	getFileReferenceService()	0	4	1
A	getMemoryCache()	0	4	1
A	getCacheManager()	0	4	1
A	getDataService()	0	4	1

<?php

namespace Fab\Media\Hook;

/*
 * This file is part of the Fab/Media project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use Fab\Vidi\Service\DataService;
use Fab\Vidi\Utility\BackendUtility;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;

/**
 * Hook Functions for the 'DataHandler'.
 */
class DataHandlerHook
{

    /**
     * Store indexed file before the Data Handler start "working".
     *
     * @var array
     */
    protected $beforeDataHandlerProcessFileIdentifiers = [];

    /**
     * Store indexed file after the Data Handler has done its job.
     *
     * @var array
     */
    protected $afterDataHandlerProcessFileIdentifiers = [];

    /**
     * Internal key for the Cache Manager.
     *
     * @var string
     */
    protected $registerKey = 'media-hook-elementsToKeepTrack';

    /**
     * First procedures to launch before all operations in DataHandler.
     *
     * Feed variable $this->beforeDataHandlerProcessFileIdentifiers
     *
     * @param \TYPO3\CMS\Core\DataHandling\DataHandler $caller TCEMain Object
     * @return void
     */
    public function processDatamap_beforeStart(DataHandler $caller)
    {

        // Use a register to keep track of files.
        // It is required according to TCEMain behaviour which register "elements to be deleted".
        // Those element must not be forgotten.
        $this->initializeFileRegister();
        $this->registerFilesToKeepTrack();

        foreach ($caller->datamap as $tableName => $configuration) {

This code seems to be duplicated across your project.

            $id = key($configuration);
            if (!MathUtility::canBeInterpretedAsInteger($id)) {
                continue;
            }

            /** @var $refIndexObj \TYPO3\CMS\Core\Database\ReferenceIndex */
            $refIndexObj = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Database\ReferenceIndex::class);
            if (\TYPO3\CMS\Backend\Utility\BackendUtility::isTableWorkspaceEnabled($tableName)) {
                $refIndexObj->setWorkspaceId($caller->BE_USER->workspace);
            }
            $indexes = $refIndexObj->updateRefIndexTable($tableName, $id);

            // Make sure $index is an array.
            if (!is_array($indexes)) {
                $indexes = [];
            }

            $fileIdentifiers = $this->lookForFiles($indexes);
            $this->addBeforeDataHandlerProcessFileIdentifiers($fileIdentifiers);
        }
    }

    /**
     * Last procedures to launch after all operations in DataHandler.
     *
     * Process field "number_of_references" which may require updates.
     *
     * @param \TYPO3\CMS\Core\DataHandling\DataHandler $caller TCEMain Object
     * @return void
     */
    public function processDatamap_afterAllOperations(DataHandler $caller)
    {

        // First collect files which have been involved.
        foreach ($caller->datamap as $tableName => $configuration) {

This code seems to be duplicated across your project.

            $id = key($configuration);

            /** @var $refIndexObj \TYPO3\CMS\Core\Database\ReferenceIndex */
            $refIndexObj = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Database\ReferenceIndex::class);
            if (\TYPO3\CMS\Backend\Utility\BackendUtility::isTableWorkspaceEnabled($tableName)) {
                $refIndexObj->setWorkspaceId($caller->BE_USER->workspace);
            }
            $indexes = $refIndexObj->updateRefIndexTable($tableName, $id);

            // Make sure $index is an array.
            if (!is_array($indexes)) {
                $indexes = [];
            }

            $fileIdentifiers = $this->lookForFiles($indexes);
            $this->addAfterDataHandlerProcessFileIdentifiers($fileIdentifiers);
        }

        // After collecting files, update the column "number_of_references".
        foreach ($this->getFileToProcess() as $fileIdentifier) {
            try {
                $file = ResourceFactory::getInstance()->getFileObject($fileIdentifier);
                $numberOfReferences = $this->getFileReferenceService()->countTotalReferences($file);

                $values = array(
                    'number_of_references' => $numberOfReferences
                );
                $this->getDataService()->update('sys_file', $values, ['uid' => $file->getUid()]);
            } catch (FileDoesNotExistException $fileDoesNotExistException) {

The class TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException does not exist. Did you forget a USE statement, or did you not list all dependencies?

                // Do nothing here. A file that does not exist needs no update.
                // See https://github.com/fabarea/media/issues/159 for more information.
            }
        }
    }

    /**
     * @return void
     */
    protected function initializeFileRegister()
    {

        $items = $this->getMemoryCache()->get($this->registerKey);
        if (!is_array($items)) {
            $this->getMemoryCache()->set($this->registerKey, []);
        }
    }

    /**
     * @return void
     */
    protected function registerFilesToKeepTrack()
    {
        $fileIdentifiers = [];
        $elementsToBeDeleted = $this->getMemoryCache()->get('core-t3lib_TCEmain-elementsToBeDeleted');
        if (is_array($elementsToBeDeleted)) {
            foreach ($elementsToBeDeleted as $tableName => $element) {

                if ($tableName === 'sys_file_reference') {

                    $fileReferenceIdentifier = key($element);
                    if ($element[$fileReferenceIdentifier] === true) {
                        $fileIdentifier = $this->findFileByFileReference($fileReferenceIdentifier);
                        $fileIdentifiers[] = $fileIdentifier;
                    }
                }
            }
        }

        // Put back in the memory cache the value.
        $items = $this->getMemoryCache()->get($this->registerKey);
        $mergedItems = array_merge($items, $fileIdentifiers);
        $this->getMemoryCache()->set($this->registerKey, $mergedItems);
    }

    /**
     * @return array
     */
    protected function getRegisteredFiles()
    {
        $files = $this->getMemoryCache()->get($this->registerKey);
        return $files;
    }

    /**
     * Look for file which are within the reference index.
     *
     * @return array
     */
    protected function getFileToProcess()
    {
        $fileIdentifiers = array_merge(
            $this->beforeDataHandlerProcessFileIdentifiers,
            $this->afterDataHandlerProcessFileIdentifiers,
            $this->getRegisteredFiles()
        );
        return array_unique($fileIdentifiers);
    }

    /**
     * @param array $fileIdentifiers
     * @return void
     */
    protected function addBeforeDataHandlerProcessFileIdentifiers(array $fileIdentifiers)
    {
        $this->beforeDataHandlerProcessFileIdentifiers = array_merge($this->beforeDataHandlerProcessFileIdentifiers, $fileIdentifiers);
    }

    /**
     * @param array $fileIdentifiers
     * @return void
     */
    protected function addAfterDataHandlerProcessFileIdentifiers(array $fileIdentifiers)
    {
        $this->afterDataHandlerProcessFileIdentifiers = array_merge($this->afterDataHandlerProcessFileIdentifiers, $fileIdentifiers);
    }

    /**
     * Look for file which are within the reference index.
     *
     * @param array $indexes
     * @return array
     */
    protected function lookForFiles(array $indexes)
    {

        $fileIdentifiers = [];
        if (isset($indexes['relations'])) {

            foreach ($indexes['relations'] as $index) {
                if (is_array($index)) {
                    if ($this->isSoftReferenceImage($index)) {
                        $fileIdentifiers[] = $index['ref_uid'];
                    } elseif ($this->isSoftReferenceLink($index)) {
                        $fileIdentifiers[] = $index['ref_uid'];
                    } elseif ($this->isFileReference($index)) {
                        $fileIdentifiers[] = $this->findFileByFileReference($index['ref_uid']);
                    }
                }
            }
        }

        return $fileIdentifiers;
    }

    /**
     * @param array $index
     * @return bool
     */
    public function isFileReference(array $index)
    {
        return $index['ref_table'] === 'sys_file_reference';
    }

    /**
     * @param array $index
     * @return bool
     */
    public function isSoftReferenceLink(array $index)
    {
        return $index['softref_key'] === 'typolink_tag' && $index['ref_table'] === 'sys_file';
    }

    /**
     * @param array $index
     * @return bool
     */
    public function isSoftReferenceImage(array $index)
    {
        return $index['softref_key'] === 'rtehtmlarea_images' && $index['ref_table'] === 'sys_file';
    }

    /**
     * Retrieve the File identifier.
     *
     * @param $fileReferenceIdentifier
     * @return int
     * @throws \Exception
     */
    protected function findFileByFileReference($fileReferenceIdentifier)
    {
        $record = $this->getDataService()->getRecord(
            'sys_file_reference',
            [
                'uid' => $fileReferenceIdentifier
            ]
        );

        if (empty($record)) {
            throw new \Exception('There is something broken with the File References. Consider updating the Reference Index.', 1408619796);
        }

        $fileIdentifier = $record['uid_local'];
        return $fileIdentifier;
    }

    /**
     * @return \Fab\Media\Resource\FileReferenceService|object
     */
    protected function getFileReferenceService()
    {
        return GeneralUtility::makeInstance(\Fab\Media\Resource\FileReferenceService::class);
    }

    /**
     * Gets an instance of the memory cache.
     *
     * @return \TYPO3\CMS\Core\Cache\Frontend\VariableFrontend
     */
    protected function getMemoryCache()
    {
        return $this->getCacheManager()->getCache('cache_runtime');
    }

    /**
     * Create and returns an instance of the CacheManager
     *
     * @return \TYPO3\CMS\Core\Cache\CacheManager|object
     */
    protected function getCacheManager()
    {
        return GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class);
    }

    /**
     * @return object|DataService
     */
    protected function getDataService(): DataService
    {
        return GeneralUtility::makeInstance(DataService::class);
    }

}