SimpleDataHandlerController.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Backend\Controller;

/*
 * 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\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Backend\Clipboard\Clipboard;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Messaging\AbstractMessage;
use TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;

class SimpleDataHandlerController
{
    public $flags;

    public $data;

    public $cmd;

    public $mirror;

    public $cacheCmd;

    public $redirect;

    public $prErr;

    public $CB;

    public $uPT;

    public $tce;

    public function __construct()
    {
        $GLOBALS['SOBE'] = $this;
        $this->init();
    }

    public function init()
    {
        $beUser = $this->getBackendUser();
        // GPvars:
        $this->flags = GeneralUtility::_GP('flags');
        $this->data = GeneralUtility::_GP('data');
        $this->cmd = GeneralUtility::_GP('cmd');
        $this->mirror = GeneralUtility::_GP('mirror');
        $this->cacheCmd = GeneralUtility::_GP('cacheCmd');
        $this->redirect = GeneralUtility::sanitizeLocalUrl(GeneralUtility::_GP('redirect'));
        $this->prErr = GeneralUtility::_GP('prErr');
        $this->CB = GeneralUtility::_GP('CB');
        $this->uPT = GeneralUtility::_GP('uPT');
        // Creating DataHandler object
        $this->tce = GeneralUtility::makeInstance(DataHandler::class);
        // Configuring based on user prefs.
        if ($beUser->uc['recursiveDelete']) {
            // TRUE if the delete Recursive flag is set.
            $this->tce->deleteTree = 1;
        }
        if ($beUser->uc['copyLevels']) {
            // Set to number of page-levels to copy.
            $this->tce->copyTree = MathUtility::forceIntegerInRange($beUser->uc['copyLevels'], 0, 100);
        }
        if ($beUser->uc['neverHideAtCopy']) {
            $this->tce->neverHideAtCopy = 1;
        }
        $TCAdefaultOverride = $beUser->getTSConfigProp('TCAdefaults');
        if (is_array($TCAdefaultOverride)) {
            $this->tce->setDefaultsFromUserTS($TCAdefaultOverride);
        }
        // Reverse order.
        if ($this->flags['reverseOrder']) {
            $this->tce->reverseOrder = 1;
        }
    }

    public function initClipboard()
    {
        if (is_array($this->CB)) {
            $clipObj = GeneralUtility::makeInstance(Clipboard::class);
            $clipObj->initializeClipboard();
            if ($this->CB['paste']) {
                $clipObj->setCurrentPad($this->CB['pad']);
                $this->cmd = $clipObj->makePasteCmdArray(
                    $this->CB['paste'],
                    $this->cmd,
                    isset($this->CB['update']) ? $this->CB['update'] : null
                );
            }
            if ($this->CB['delete']) {
                $clipObj->setCurrentPad($this->CB['pad']);
                $this->cmd = $clipObj->makeDeleteCmdArray($this->cmd);
            }
        }
    }

    public function main()
    {
        // LOAD DataHandler with data and cmd arrays:
        $this->tce->start($this->data, $this->cmd);
        if (is_array($this->mirror)) {
            $this->tce->setMirror($this->mirror);
        }
        // Register uploaded files
        $this->tce->process_uploads($_FILES);
        // Execute actions:
        $this->tce->process_datamap();
        $this->tce->process_cmdmap();
        // Clearing cache:
        if (!empty($this->cacheCmd)) {
            $this->tce->clear_cacheCmd($this->cacheCmd);
        }
        // Update page tree?
        if ($this->uPT && (isset($this->data['pages']) || isset($this->cmd['pages']))) {
            BackendUtility::setUpdateSignal('updatePageTree');
        }
    }

    public function mainAction(ServerRequestInterface $request, ResponseInterface $response)
    {
        $this->initClipboard();
        $this->main();

        // Write errors to flash message queue (if not explicitly disabled)
        if ($this->prErr || $this->prErr === null) {
            $this->tce->printLogErrorMessages();
        }
        if ($this->redirect) {
            $response = $response
                ->withHeader('Location', GeneralUtility::locationHeaderUrl($this->redirect))
                ->withStatus(303);
        }
        return $response;
    }

    public function processAjaxRequest(ServerRequestInterface $request, ResponseInterface $response)
    {
        // do the regular / main logic
        $this->initClipboard();
        $this->main();

        $flashMessageService = GeneralUtility::makeInstance(FlashMessageService::class);

        $content = [
            'redirect' => $this->redirect,
            'messages' => [],
            'hasErrors' => false
        ];

        // Prints errors (= write them to the message queue, if not explicitly disabled)
        if ($this->prErr || $this->prErr === null) {
            $content['hasErrors'] = !empty($this->tce->errorLog);
            $this->tce->printLogErrorMessages();
        }

        $messages = $flashMessageService->getMessageQueueByIdentifier()->getAllMessagesAndFlush();
        if (!empty($messages)) {
            foreach ($messages as $message) {
                $content['messages'][] = [
                    'title'    => $message->getTitle(),
                    'message'  => $message->getMessage(),
                    'severity' => $message->getSeverity()
                ];
                if ($message->getSeverity() === AbstractMessage::ERROR) {
                    $content['hasErrors'] = true;
                }
            }
        }

        $response->getBody()->write(json_encode($content));
        return $response;
    }

    protected function getBackendUser()
    {
        return $GLOBALS['BE_USER'];
    }
}