9.5/_file_collector_8php_source.html

<?php

namespace ‪TYPO3\CMS\Frontend\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\LinkHandling\LinkService;

use ‪TYPO3\CMS\Core\Resource\Exception;

use ‪TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException;

use ‪TYPO3\CMS\Core\Resource\FileCollectionRepository;

use ‪TYPO3\CMS\Core\Resource\FileInterface;

use ‪TYPO3\CMS\Core\Resource\FileRepository;

use ‪TYPO3\CMS\Core\Resource\Folder;

use ‪TYPO3\CMS\Core\Resource\ResourceFactory;

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


class ‪FileCollector implements \Countable, LoggerAwareInterface

{

    use LoggerAwareTrait;


    protected ‪$files = [];


    protected ‪$fileRepository;


    protected ‪$fileCollectionRepository;


    protected ‪$resourceFactory;


    public function ‪addFiles(array $fileUids = [])

    {

        if (!empty($fileUids)) {

            foreach ($fileUids as $fileUid) {

                try {

                    $this->‪addFileObject($this->‪getResourceFactory()->getFileObject($fileUid));

                } catch (‪Exception $e) {

                    $this->logger->warning(

                        'The file with uid  "' . $fileUid

                        . '" could not be found and won\'t be included in frontend output',

                        ['exception' => $e]

                    );

                }

            }

        }

    }


    public function ‪addFilesFromRelation($relationTable, $relationField, array $referenceRecord)

    {

        if (is_object(‪$GLOBALS['TSFE']) && is_object(‪$GLOBALS['TSFE']->sys_page)) {

            $fileReferences = $this->‪getFileReferences($relationTable, $relationField, $referenceRecord);

        } else {

            $fileReferences = $this->‪getFileRepository()->‪findByRelation($relationTable, $relationField, $referenceRecord['uid']);

        }


        if (!empty($fileReferences)) {

            $this->‪addFileObjects($fileReferences);

        }

    }


    public function ‪addFileReferences(array $fileReferenceUids = [])

    {

        foreach ($fileReferenceUids as $fileReferenceUid) {

            $fileObject = $this->‪getFileRepository()->‪findFileReferenceByUid($fileReferenceUid);

            $this->‪addFileObject($fileObject);

        }

    }


    public function ‪addFilesFromFileCollections(array $fileCollectionUids = [])

    {

        foreach ($fileCollectionUids as $fileCollectionUid) {

            $this->‪addFilesFromFileCollection($fileCollectionUid);

        }

    }


    public function ‪addFilesFromFileCollection($fileCollectionUid = null)

    {

        if (!empty($fileCollectionUid)) {

            try {

                $fileCollection = $this->‪getFileCollectionRepository()->‪findByUid($fileCollectionUid);


                if ($fileCollection instanceof \‪TYPO3\CMS\Core\Resource\Collection\AbstractFileCollection) {

                    $fileCollection->loadContents();

                    ‪$files = $fileCollection->getItems();


                    $this->‪addFileObjects(‪$files);

                }

            } catch (‪Exception $e) {

                $this->logger->warning(

                    'The file-collection with uid  "' . $fileCollectionUid

                    . '" could not be found or contents could not be loaded and won\'t be included in frontend output.',

                    ['exception' => $e]

                );

            }

        }

    }


    public function ‪addFilesFromFolders(array $folderIdentifiers = [], $recursive = false)

    {

        foreach ($folderIdentifiers as $folderIdentifier) {

            $this->‪addFilesFromFolder($folderIdentifier, $recursive);

        }

    }


    public function ‪addFilesFromFolder($folderIdentifier, $recursive = false)

    {

        if ($folderIdentifier) {

            try {

                if (strpos($folderIdentifier, 't3://folder') === 0) {

                    // a t3://folder link to a folder in FAL

                    $linkService = GeneralUtility::makeInstance(LinkService::class);

                    $data = $linkService->resolveByStringRepresentation($folderIdentifier);

                    $folder = $data['folder'];

                } else {

                    $folder = $this->‪getResourceFactory()->‪getFolderObjectFromCombinedIdentifier($folderIdentifier);

                }

                if ($folder instanceof ‪Folder) {

                    ‪$files = $folder->getFiles(0, 0, ‪Folder::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS, $recursive);

                    $this->‪addFileObjects(array_values(‪$files));

                }

            } catch (‪Exception $e) {

                $this->logger->warning(

                    'The folder with identifier  "' . $folderIdentifier

                    . '" could not be found and won\'t be included in frontend output',

                    ['exception' => $e]

                );

            }

        }

    }


    public function ‪sort($sortingProperty = '', $sortingOrder = 'ascending')

    {

        if ($sortingProperty !== '' && ‪count($this->files) > 1) {

            @usort(

                $this->files,

                function (

                    ‪FileInterface $a,

                    ‪FileInterface $b

                ) use ($sortingProperty) {

                    if ($a->‪hasProperty($sortingProperty) && $b->‪hasProperty($sortingProperty)) {

                        return strnatcasecmp($a->getProperty($sortingProperty), $b->getProperty($sortingProperty));

                    }

                    return 0;

                }

            );


            switch (strtolower($sortingOrder)) {

                case 'descending':

                case 'desc':

                    $this->files = array_reverse($this->files);

                    break;

                case 'random':

                case 'rand':

                    shuffle($this->files);

                    break;

            }

        }

    }


    public function ‪addFileObject(‪FileInterface $file)

    {

        $this->files[] = $file;

    }


    public function ‪addFileObjects(‪$files)

    {

        $this->files = array_merge($this->files, ‪$files);

    }


    public function ‪getFiles()

    {

        return ‪$this->files;

    }


    public function ‪count()

    {

        return ‪count($this->files);

    }


    protected function ‪getFileReferences($tableName, $fieldName, array $element): array

    {

        ‪$fileRepository = GeneralUtility::makeInstance(FileRepository::class);

        $currentId = !empty($element['uid']) ? $element['uid'] : 0;


        // Fetch the references of the default element

        try {

            $references = ‪$fileRepository->‪findByRelation($tableName, $fieldName, $currentId);

        } catch (FileDoesNotExistException $e) {

            return [];

        } catch (\InvalidArgumentException $e) {

            $logMessage = $e->getMessage() . ' (table: "' . $tableName . '", fieldName: "' . $fieldName . '", currentId: ' . $currentId . ')';

            $this->logger->error($logMessage, ['exception' => $e]);

            return [];

        }


        $localizedId = null;

        if (isset($element['_LOCALIZED_UID'])) {

            $localizedId = $element['_LOCALIZED_UID'];

        } elseif (isset($element['_PAGES_OVERLAY_UID'])) {

            $localizedId = $element['_PAGES_OVERLAY_UID'];

        }


        $isTableLocalizable = (

            !empty(‪$GLOBALS['TCA'][$tableName]['ctrl']['languageField'])

            && !empty(‪$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'])

        );

        if ($isTableLocalizable && $localizedId !== null) {

            $localizedReferences = ‪$fileRepository->‪findByRelation($tableName, $fieldName, $localizedId);

            $references = $localizedReferences;

        }


        return $references;

    }


    protected function ‪getResourceFactory()

    {

        if ($this->resourceFactory === null) {

            $this->resourceFactory = GeneralUtility::makeInstance(ResourceFactory::class);

        }

        return ‪$this->resourceFactory;

    }


    protected function ‪getFileCollectionRepository()

    {

        if ($this->fileCollectionRepository === null) {

            $this->fileCollectionRepository = GeneralUtility::makeInstance(FileCollectionRepository::class);

        }

        return ‪$this->fileCollectionRepository;

    }


    protected function ‪getFileRepository()

    {

        if ($this->fileRepository === null) {

            $this->fileRepository = GeneralUtility::makeInstance(FileRepository::class);

        }

        return ‪$this->fileRepository;

    }

}