Clipboard.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Backend\Clipboard;
 
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Backend\Routing\UriBuilder;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\WorkspaceRestriction;
use ‪TYPO3\CMS\Core\Imaging\Icon;
use ‪TYPO3\CMS\Core\Imaging\IconFactory;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\Folder;
use ‪TYPO3\CMS\Core\Resource\ProcessedFile;
use ‪TYPO3\CMS\Core\Resource\ResourceFactory;
use ‪TYPO3\CMS\Core\Type\Bitmask\JsConfirmation;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\PathUtility;
 
class ‪Clipboard
{
    public array ‪$clipData = [];
 
    public bool ‪$changed = false;
 
    public string ‪$current = '';
 
    public bool ‪$lockToNormal = false;
 
    public int ‪$numberOfPads = 3;
 
    protected ‪IconFactory ‪$iconFactory;
    protected ‪UriBuilder ‪$uriBuilder;
    protected ‪ResourceFactory ‪$resourceFactory;
 
    protected ?ServerRequestInterface ‪$request = null;
 
    public function ‪__construct(‪IconFactory ‪$iconFactory, ‪UriBuilder ‪$uriBuilder, ‪ResourceFactory ‪$resourceFactory)
    {
        $this->iconFactory = ‪$iconFactory;
        $this->uriBuilder = ‪$uriBuilder;
        $this->resourceFactory = ‪$resourceFactory;
    }
 
    /*****************************************
     *
     * Initialize
     *
     ****************************************/
    public function ‪initializeClipboard(?ServerRequestInterface ‪$request = null): void
    {
        // Initialize the request
        // @todo: Clipboard does two things: It is a repository to find out which records
        //        are in the clipboard, and it is a class to help with rendering the
        //        clipboard. $request is optional and only used in rendering.
        //        It would be better to split these two aspects into single classes.
        $this->request = ‪$request ?? ‪$GLOBALS['TYPO3_REQUEST'] ?? null;
 
        $userTsConfig = $this->‪getBackendUser()->‪getTSConfig();
        // Get data
        $clipData = $this->‪getBackendUser()->‪getModuleData('clipboard', !empty($userTsConfig['options.']['saveClipboard']) ? '' : 'ses') ?: [];
        ‪$clipData += ['normal' => []];
        $this->numberOfPads = ‪MathUtility::forceIntegerInRange((int)($userTsConfig['options.']['clipboardNumberPads'] ?? 3), 0, 20);
        // Resets/reinstates the clipboard pads
        $this->clipData['normal'] = is_array(‪$clipData['normal']) ? ‪$clipData['normal'] : [];
        for ($a = 1; $a <= ‪$this->numberOfPads; $a++) {
            $index = 'tab_' . $a;
            $this->clipData[$index] = is_iterable(‪$clipData[$index] ?? null) ? ‪$clipData[$index] : [];
        }
        // Setting the current pad pointer ($this->current))
        ‪$current = (string)(‪$clipData['current'] ?? '');
        $this->current = isset($this->clipData[‪$current]) ? ‪$current : 'normal';
        $this->clipData['current'] = ‪$this->current;
    }
 
    public function ‪lockToNormal(): void
    {
        $this->‪lockToNormal = true;
        $this->current = 'normal';
    }
 
    public function ‪setCmd(array $cmd): void
    {
        $cmd['el'] ??= [];
        $cmd['el'] = is_iterable($cmd['el']) ? $cmd['el'] : [];
        foreach ($cmd['el'] as $key => $value) {
            if ($this->current === 'normal') {
                unset($this->clipData['normal']);
            }
            if ($value) {
                $this->clipData[‪$this->current]['el'][$key] = $value;
            } else {
                $this->‪removeElement((string)$key);
            }
            $this->changed = true;
        }
        // Change clipboard pad (if not locked to normal)
        if ($cmd['setP'] ?? false) {
            $this->‪setCurrentPad((string)$cmd['setP']);
        }
        // Remove element   (value = item ident: DB; '[tablename]|[uid]'    FILE: '_FILE|[md5 hash of path]'
        if ($cmd['remove'] ?? false) {
            $this->‪removeElement((string)$cmd['remove']);
            $this->changed = true;
        }
        // Remove all on current pad (value = pad-ident)
        if ($cmd['removeAll'] ?? false) {
            $this->clipData[$cmd['removeAll']] = [];
            $this->changed = true;
        }
        // Set copy mode of the tab
        if (isset($cmd['setCopyMode'])) {
            $this->clipData[‪$this->current]['mode'] = $cmd['setCopyMode'] ? 'copy' : '';
            $this->changed = true;
        }
    }
 
    public function ‪setCurrentPad(string $padIdentifier): void
    {
        // Change clipboard pad (if not locked to normal)
        if (!$this->‪lockToNormal && $this->current !== $padIdentifier) {
            if (isset($this->clipData[$padIdentifier])) {
                $this->clipData['current'] = ($this->current = $padIdentifier);
            }
            if ($this->current !== 'normal' || !$this->‪isElements()) {
                $this->clipData[‪$this->current]['mode'] = '';
            }
            // Setting mode to default (move) if no items on it or if not 'normal'
            $this->changed = true;
        }
    }
 
    public function ‪endClipboard(): void
    {
        if ($this->changed) {
            $this->‪saveClipboard();
        }
        $this->changed = false;
    }
 
    public function ‪cleanUpCBC(array $CBarr, string $table, bool $removeDeselected = false): array
    {
        foreach ($CBarr as $reference => $value) {
            $referenceTable = (string)(explode('|', $reference)[0] ?? '');
            if ($referenceTable !== $table || ($removeDeselected && !$value)) {
                unset($CBarr[$reference]);
            }
        }
        return $CBarr;
    }
 
    public function ‪printClipboard(string $table = ''): string
    {
        $attributes = [
            'table' => $table,
        ];
        GeneralUtility::makeInstance(PageRenderer::class)->loadRequireJsModule('TYPO3/CMS/Backend/ClipboardPanel');
        return '<typo3-backend-clipboard-panel ' . GeneralUtility::implodeAttributes($attributes, true) . '></typo3-backend-clipboard-panel>';
    }
 
    public function ‪getClipboardData(string $table = ''): array
    {
        $lang = $this->‪getLanguageService();
 
        $clipboardData = [
            'current' => ‪$this->current,
            'copyMode' => $this->‪currentMode(),
            'elementCount' => count($this->‪elFromTable($table)),
        ];
 
        // Initialize tabs by adding the "normal" tab
        $tabs = [
            [
                'identifier' => 'normal',
                'info' => $this->‪getTabInfo('normal', $table),
                'title' => $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.normal'),
                'description' => $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.normal-description'),
                'items' => $this->current === 'normal' ? $this->‪getTabItems('normal', $table) : [],
            ],
        ];
        // Add numeric tabs
        for ($a = 1; $a <= ‪$this->numberOfPads; $a++) {
            $tabs[] = [
                'identifier' => 'tab_' . $a,
                'info' => $this->‪getTabInfo('tab_' . $a, $table),
                'title' => sprintf($lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.cliptabs-name'), (string)$a),
                'description' => $lang->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.cliptabs-description'),
                'items' => $this->current === 'tab_' . $a ? $this->‪getTabItems('tab_' . $a, $table) : [],
            ];
        }
        // Add tabs to clipboard Data
        $clipboardData['tabs'] = $tabs;
 
        return $clipboardData;
    }
 
    protected function ‪getTabItems(string $padIdentifier, string $currentTable): array
    {
        if (!is_array($this->clipData[$padIdentifier]['el'] ?? false)) {
            return [];
        }
 
        $records = [];
        foreach ($this->clipData[$padIdentifier]['el'] as $reference => $value) {
            if (!$value) {
                // Skip element if empty value
                continue;
            }
            [$table, $uid] = explode('|', $reference);
            // Rendering files/directories on the clipboard
            if ($table === '_FILE') {
                $fileObject = $this->resourceFactory->retrieveFileOrFolderObject($value);
                if ($fileObject) {
                    $thumb = '';
                    $folder = $fileObject instanceof ‪Folder;
                    $size = $folder ? '' : '(' . GeneralUtility::formatSize((int)$fileObject->getSize()) . 'bytes)';
                    if (!$folder && ($fileObject->isImage() || $fileObject->isMediaFile())) {
                        $processedFile = $fileObject->process(
                            ‪ProcessedFile::CONTEXT_IMAGEPREVIEW,
                            [
                                'width' => 64,
                                'height' => 64,
                            ]
                        );
 
                        $thumb = '<img src="' . htmlspecialchars($processedFile->getPublicUrl() ?? '') . '" ' .
                            'width="' . htmlspecialchars((string)$processedFile->getProperty('width')) . '" ' .
                            'height="' . htmlspecialchars((string)$processedFile->getProperty('height')) . '" ' .
                            'title="' . htmlspecialchars($processedFile->getName()) . '" alt="" />';
                    }
                    $linkItemText = GeneralUtility::fixed_lgd_cs($fileObject->getName(), (int)($this->getBackendUser()->uc['titleLen'] ?? 0));
                    $combinedIdentifier = ($parentFolder = $fileObject->getParentFolder()) instanceof ‪Folder ? $parentFolder->‪getCombinedIdentifier() : '';
                    $filesRequested = $currentTable === '_FILE';
                    $records[] = [
                        'identifier' => '_FILE|' . md5($value),
                        'icon' => '<span title="' . htmlspecialchars($fileObject->getName() . ' ' . $size) . '">' . $this->iconFactory->getIconForResource(
                            $fileObject,
                            ‪Icon::SIZE_SMALL
                        )->render() . '</span>',
                        'title' => $this->‪linkItemText(htmlspecialchars($linkItemText), $combinedIdentifier, $filesRequested),
                        'thumb' => $thumb,
                        'infoDataDispatch' => [
                            'action' => 'TYPO3.InfoWindow.showItem',
                            'args' => GeneralUtility::jsonEncodeForHtmlAttribute([$table, $value], false),
                        ],
                    ];
                } else {
                    // If the file did not exist (or is illegal) then it is removed from the clipboard immediately:
                    unset($this->clipData[$padIdentifier]['el'][$reference]);
                    $this->changed = true;
                }
            } else {
                // Rendering records:
                $record = BackendUtility::getRecordWSOL($table, (int)$uid);
                if (is_array($record)) {
                    $isRequestedTable = $currentTable !== '_FILE';
                    $records[] = [
                        'identifier' => $table . '|' . $uid,
                        'icon' => $this->iconFactory->getIconForRecord($table, $record, ‪Icon::SIZE_SMALL)->render(),
                        'title' => $this->‪linkItemText(htmlspecialchars(GeneralUtility::fixed_lgd_cs(BackendUtility::getRecordTitle(
                            $table,
                            $record
                        ), $this->‪getBackendUser()->uc['titleLen'])), $record, $isRequestedTable),
                        'infoDataDispatch' => [
                            'action' => 'TYPO3.InfoWindow.showItem',
                            'args' => GeneralUtility::jsonEncodeForHtmlAttribute([$table, (int)$uid], false),
                        ],
                    ];
 
                    $localizationData = $this->‪getLocalizations($table, $record, $isRequestedTable);
                    if (!empty($localizationData)) {
                        $records = array_merge($records, $localizationData);
                    }
                } else {
                    unset($this->clipData[$padIdentifier]['el'][$reference]);
                    $this->changed = true;
                }
            }
        }
        $this->‪endClipboard();
        return $records;
    }
 
    public function ‪hasElements(): bool
    {
        foreach ($this->clipData as $data) {
            if (isset($data['el']) && is_array($data['el']) && !empty($data['el'])) {
                return true;
            }
        }
        return false;
    }
 
    protected function ‪getLocalizations(string $table, array $parentRecord, bool $isRequestedTable): array
    {
        if (!BackendUtility::isTableLocalizable($table)) {
            return [];
        }
 
        $records = [];
        $tcaCtrl = ‪$GLOBALS['TCA'][$table]['ctrl'];
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
        $queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
 
        $queryBuilder
            ->select('*')
            ->from($table)
            ->where(
                $queryBuilder->expr()->eq(
                    $tcaCtrl['transOrigPointerField'],
                    $queryBuilder->createNamedParameter((int)$parentRecord['uid'], ‪Connection::PARAM_INT)
                ),
                $queryBuilder->expr()->neq(
                    $tcaCtrl['languageField'],
                    $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT)
                ),
                $queryBuilder->expr()->gt(
                    'pid',
                    $queryBuilder->createNamedParameter(-1, ‪Connection::PARAM_INT)
                )
            )
            ->orderBy($tcaCtrl['languageField']);
 
        if (BackendUtility::isTableWorkspaceEnabled($table)) {
            $queryBuilder->getRestrictions()->add(
                GeneralUtility::makeInstance(WorkspaceRestriction::class, $this->‪getBackendUser()->workspace)
            );
        }
 
        foreach ($queryBuilder->executeQuery()->fetchAllAssociative() as $record) {
            $title = htmlspecialchars(GeneralUtility::fixed_lgd_cs(BackendUtility::getRecordTitle($table, $record), $this->‪getBackendUser()->uc['titleLen']));
            if (!$isRequestedTable) {
                // In case the current table is not the requested table, e.g. "_FILE", wrap title in "muted" style
                $title = '<span class="text-muted">' . $title . '</span>';
            }
            $records[] = [
                'icon' => $this->iconFactory->getIconForRecord($table, $record, ‪Icon::SIZE_SMALL)->render(),
                'title' => $title,
                'infoDataDispatch' => [
                    'action' => 'TYPO3.InfoWindow.showItem',
                    'args' => GeneralUtility::jsonEncodeForHtmlAttribute([$table, (int)$record['uid']], false),
                ],
            ];
        }
 
        return $records;
    }
 
    protected function ‪getTabInfo(string $padIdentifier, string $table = ''): string
    {
        $el = count($this->‪elFromTable($table, $padIdentifier));
        if (!$el) {
            return '';
        }
        $modeLabel = ($this->clipData['normal']['mode'] ?? '') === 'copy' ? $this->‪clipboardLabel('cm.copy') : $this->‪clipboardLabel('cm.cut');
        return ' (' . ($padIdentifier === 'normal' ? $modeLabel : htmlspecialchars((string)$el)) . ')';
    }
 
    protected function ‪linkItemText(string $itemText, $reference, bool $isRequestedTable): string
    {
        if (is_array($reference)) {
            if ($isRequestedTable) {
                // Wrap in link to corresponding page in recordlist in case current requested table matches
                $itemText = '<a href="' . htmlspecialchars((string)$this->uriBuilder->buildUriFromRoute('web_list', ['id' => $reference['pid']])) . '">' . $itemText . '</a>';
            } else {
                $itemText = '<span class="text-muted">' . $itemText . '</span>';
            }
        } elseif (is_string($reference)) {
            if ($isRequestedTable && ‪ExtensionManagementUtility::isLoaded('filelist')) {
                // Wrap in link to the files folder in case current requested table matches and filelist is loaded
                $itemText = '<a href="' . htmlspecialchars((string)$this->uriBuilder->buildUriFromRoute('file_FilelistList', ['id' => $reference])) . '">' . $itemText . '</a>';
            } else {
                $itemText = '<span class="text-muted">' . $itemText . '</span>';
            }
        }
        return $itemText;
    }
 
    public function ‪selUrlDB(string $table, int $uid, bool $copy = false, bool $deselect = false): string
    {
        return $this->‪buildUrl(['CB' => [
            'el' => [
                $table . '|' . $uid => $deselect ? 0 : 1,
            ],
            'setCopyMode' => (int)$copy,
        ]]);
    }
 
    public function ‪selUrlFile(string $path, bool $copy = false, bool $deselect = false): string
    {
        return $this->‪buildUrl(['CB' => [
            'el' => [
                '_FILE|' . md5($path) => $deselect ? '' : $path,
            ],
            'setCopyMode' => (int)$copy,
        ]]);
    }
 
    public function ‪pasteUrl(string $table, $identifier, bool $setRedirect = true, array $update = null): string
    {
        $urlParameters = [
            'CB' => [
                'paste' => $table . '|' . $identifier,
                'pad' => ‪$this->current,
            ],
        ];
        if ($setRedirect) {
            $urlParameters['redirect'] = $this->‪buildUrl(['CB' => []]);
        }
        if (is_array($update)) {
            $urlParameters['CB']['update'] = $update;
        }
        return (string)$this->uriBuilder->buildUriFromRoute($table === '_FILE' ? 'tce_file' : 'tce_db', $urlParameters);
    }
 
    public function ‪confirmMsgText(
        string $table,
        $reference,
        string $type,
        array $selectedElements,
        string $columnLabel = ''
    ): string {
        if (!$this->‪getBackendUser()->jsConfirmation(‪JsConfirmation::COPY_MOVE_PASTE)) {
            return '';
        }
 
        $labelKey = 'LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:mess.'
            . ($this->‪currentMode() === 'copy' ? 'copy' : 'move')
            . ($this->current === 'normal' ? '' : 'cb') . '_' . $type;
        $confirmationMessage = $this->‪getLanguageService()->‪sL($labelKey . ($columnLabel ? '_colPos' : ''));
 
        if ($table === '_FILE' && is_string($reference)) {
            $recordTitle = ‪PathUtility::basename($reference);
            if ($this->current === 'normal') {
                $selectedItem = reset($selectedElements);
                $selectedRecordTitle = ‪PathUtility::basename($selectedItem);
            } else {
                $selectedRecordTitle = count($selectedElements);
            }
        } else {
            $recordTitle = $table === 'pages' && !is_array($reference)
                ? ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['sitename']
                : BackendUtility::getRecordTitle($table, $reference);
            if ($this->current === 'normal') {
                $selectedItem = $this->‪getSelectedRecord();
                $selectedRecordTitle = $selectedItem['_RECORD_TITLE'];
            } else {
                $selectedRecordTitle = count($selectedElements);
            }
        }
        // @TODO
        // This can get removed as soon as the "_colPos" label is translated
        // into all available locallang languages.
        if (!$confirmationMessage && $columnLabel) {
            $recordTitle .= ' | ' . $columnLabel;
            $confirmationMessage = $this->‪getLanguageService()->‪sL($labelKey);
        }
 
        return sprintf(
            $confirmationMessage,
            GeneralUtility::fixed_lgd_cs($selectedRecordTitle, 30),
            GeneralUtility::fixed_lgd_cs($recordTitle, 30),
            GeneralUtility::fixed_lgd_cs($columnLabel, 30)
        );
    }
 
    protected function ‪clipboardLabel(string $key): string
    {
        return htmlspecialchars($this->‪getLanguageService()->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:' . $key));
    }
 
    /*****************************************
     *
     * Helper functions
     *
     ****************************************/
    public function ‪removeElement(string $elementKey): void
    {
        unset($this->clipData[$this->current]['el'][$elementKey]);
        $this->changed = true;
    }
 
    protected function ‪saveClipboard(): void
    {
        $this->‪getBackendUser()->‪pushModuleData('clipboard', $this->clipData);
    }
 
    public function ‪currentMode(): string
    {
        return ($this->clipData[$this->current]['mode'] ?? '') === 'copy' ? 'copy' : 'cut';
    }
 
    public function ‪cleanCurrent(): void
    {
        if (!is_array($this->clipData[$this->current]['el'] ?? false)) {
            return;
        }
 
        foreach ($this->clipData[$this->current]['el'] as $reference => $value) {
            [$table, $uid] = explode('|', $reference);
            if ($table !== '_FILE') {
                if (!$value || !is_array(BackendUtility::getRecord($table, (int)$uid, 'uid'))) {
                    unset($this->clipData[$this->current]['el'][$reference]);
                    $this->changed = true;
                }
            } elseif (!$value) {
                unset($this->clipData[$this->current]['el'][$reference]);
                $this->changed = true;
            } else {
                try {
                    $this->resourceFactory->retrieveFileOrFolderObject($value);
                } catch (‪ResourceDoesNotExistException $e) {
                    // The file has been deleted in the meantime, so just remove it silently
                    unset($this->clipData[$this->current]['el'][$reference]);
                }
            }
        }
    }
 
    public function ‪elFromTable(string $matchTable = '', string $padIdentifier = ''): array
    {
        $padIdentifier = $padIdentifier ?: ‪$this->current;
 
        if (!is_array($this->clipData[$padIdentifier]['el'] ?? false)) {
            return [];
        }
 
        $elements = [];
        foreach ($this->clipData[$padIdentifier]['el'] as $reference => $value) {
            if (!$value) {
                continue;
            }
            [$table, $uid] = explode('|', $reference);
            if ($table !== '_FILE') {
                if ((!$matchTable || $table === $matchTable) && (‪$GLOBALS['TCA'][$table] ?? false)) {
                    $elements[$reference] = $padIdentifier === 'normal' ? $value : $uid;
                }
            } elseif ($table === $matchTable) {
                $elements[$reference] = $value;
            }
        }
        return $elements;
    }
 
    public function ‪isSelected(string $table, $identifier): string
    {
        $key = $table . '|' . $identifier;
        $mode = $this->current === 'normal' ? $this->‪currentMode() : 'any';
        return !empty($this->clipData[$this->current]['el'][$key]) ? $mode : '';
    }
 
    public function ‪getSelectedRecord(): array
    {
        $elements = $this->‪elFromTable();
        reset($elements);
        [$table, $uid] = explode('|', (string)key($elements));
        if (!$this->‪isSelected($table, (int)$uid)) {
            return [];
        }
        $selectedRecord = BackendUtility::getRecordWSOL($table, (int)$uid);
        $selectedRecord['_RECORD_TITLE'] = BackendUtility::getRecordTitle($table, $selectedRecord);
        return $selectedRecord;
    }
 
    protected function ‪isElements(): bool
    {
        return is_array($this->clipData[$this->current]['el'] ?? null) && !empty($this->clipData[$this->current]['el']);
    }
 
    protected function ‪getLanguageService(): ‪LanguageService
    {
        return ‪$GLOBALS['LANG'];
    }
 
    protected function ‪getBackendUser(): ‪BackendUserAuthentication
    {
        return ‪$GLOBALS['BE_USER'];
    }
 
    protected function ‪buildUrl(array $parameters = []): string
    {
        if ($this->request === null) {
            throw new \RuntimeException(
                'Request object must be set to generate clipboard URL\'s',
                1633604720
            );
        }
        return (string)$this->uriBuilder->buildUriFromRoute(
            $this->request->getAttribute('route')->getOption('_identifier'),
            array_replace($this->request->getQueryParams(), $parameters)
        );
    }
}