FrontendEditDataHandler.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
 
namespace ‪TYPO3\CMS\Feedit\DataHandling;
 
/*
 * 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 ‪TYPO3\CMS\Backend\FrontendBackendUserAuthentication;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\EndTimeRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\FrontendGroupRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\HiddenRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\StartTimeRestriction;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Frontend\View\AdminPanelView;
 
class ‪FrontendEditDataHandler
{
    protected ‪$configuration;
 
    protected ‪$user;
 
    public function ‪__construct(array ‪$configuration, ‪FrontendBackendUserAuthentication ‪$user = null)
    {
        $this->user = ‪$user ?: ‪$GLOBALS['BE_USER'];
        $this->configuration = ‪$configuration;
    }
 
    public function ‪editAction()
    {
        // Commands
        list($table, $uid) = explode(':', $this->configuration['record']);
        $uid = (int)$uid;
        $cmd = $this->configuration['cmd'];
        // Look for some configuration data that indicates we should save.
        if (($this->configuration['doSave'] || $this->configuration['update'] || $this->configuration['update_close']) && is_array($this->configuration['data'])) {
            $cmd = 'save';
        }
        if ($cmd === 'save' || $cmd && $table && $uid && isset(‪$GLOBALS['TCA'][$table])) {
            // Perform the requested editing command.
            $cmdAction = 'do' . ucwords($cmd);
            if (method_exists($this, $cmdAction)) {
                call_user_func_array([$this, $cmdAction], [$table, $uid]);
            } else {
                throw new \UnexpectedValueException('The specified frontend edit command (' . $cmd . ') is not valid.', 1225818110);
            }
        }
    }
 
    protected function ‪doHide(string $table, int $uid)
    {
        $hideField = ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled'];
        if ($hideField) {
            $recData = [];
            $recData[$table][$uid][$hideField] = 1;
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            $dataHandler->start($recData, []);
            $dataHandler->process_datamap();
        }
    }
 
    protected function ‪doUnhide(string $table, int $uid)
    {
        $hideField = ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled'];
        if ($hideField) {
            $recData = [];
            $recData[$table][$uid][$hideField] = 0;
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            $dataHandler->start($recData, []);
            $dataHandler->process_datamap();
        }
    }
 
    protected function ‪doUp(string $table, int $uid)
    {
        $this->‪move($table, $uid, 'up');
    }
 
    protected function ‪doDown(string $table, int $uid)
    {
        $this->‪move($table, $uid, 'down');
    }
 
    protected function ‪doMoveAfter(string $table, int $uid)
    {
        $afterUID = (int)$this->configuration['moveAfter'];
        $this->‪move($table, $uid, '', $afterUID);
    }
 
    protected function ‪move(string $table, int $uid, string $direction = '', int $afterUID = 0)
    {
        $dataHandlerCommands = [];
        $sortField = ‪$GLOBALS['TCA'][$table]['ctrl']['sortby'];
        if ($sortField) {
            // Get the current record
            // Only fetch uid, pid and the fields that are necessary to detect the sorting factors
            if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['copyAfterDuplFields'])) {
                $copyAfterDuplicateFields = GeneralUtility::trimExplode(',', ‪$GLOBALS['TCA'][$table]['ctrl']['copyAfterDuplFields'], true);
            } else {
                $copyAfterDuplicateFields = [];
            }
 
            ‪$fields = $copyAfterDuplicateFields;
            ‪$fields[] = 'uid';
            ‪$fields[] = 'pid';
            ‪$fields[] = $sortField;
            ‪$fields = array_unique(‪$fields);
 
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable($table);
            $queryBuilder->getRestrictions()->removeAll();
 
            $currentRecord = $queryBuilder
                ->select(...‪$fields)
                ->from($table)
                ->where($queryBuilder->expr()->eq(
                    'uid',
                    $queryBuilder->createNamedParameter($uid, \PDO::PARAM_INT)
                ))
                ->execute()
                ->fetch();
 
            if (is_array($currentRecord)) {
                // Fetch the record before or after the current one
                // to define the data handler commands
                $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getQueryBuilderForTable($table);
 
                $queryBuilder
                    ->select('uid', 'pid')
                    ->from($table)
                    ->where($queryBuilder->expr()->eq(
                        'pid',
                        $queryBuilder->createNamedParameter($currentRecord['pid'], \PDO::PARAM_INT)
                    ))
                    ->setMaxResults(2);
 
                // Disable the default restrictions (but not all) if the admin panel is in preview mode
                if ($this->user->adminPanel instanceof ‪AdminPanelView && $this->user->adminPanel->‪extGetFeAdminValue('preview')) {
                    $queryBuilder->getRestrictions()
                        ->removeByType(StartTimeRestriction::class)
                        ->removeByType(EndTimeRestriction::class)
                        ->removeByType(HiddenRestriction::class)
                        ->removeByType(FrontendGroupRestriction::class);
                }
 
                if (!empty($copyAfterDuplicateFields)) {
                    foreach ($copyAfterDuplicateFields as $fieldName) {
                        $queryBuilder->andWhere($queryBuilder->expr()->eq(
                            $fieldName,
                            $queryBuilder->createNamedParameter($currentRecord[$fieldName], \PDO::PARAM_STR)
                        ));
                    }
                }
                if (!empty($direction)) {
                    if ($direction === 'up') {
                        $queryBuilder->andWhere(
                            $queryBuilder->expr()->lt(
                                $sortField,
                                $queryBuilder->createNamedParameter($currentRecord[$sortField], \PDO::PARAM_INT)
                            )
                        );
                        $queryBuilder->orderBy($sortField, 'DESC');
                    } else {
                        $queryBuilder->andWhere(
                            $queryBuilder->expr()->gt(
                                $sortField,
                                $queryBuilder->createNamedParameter($currentRecord[$sortField], \PDO::PARAM_INT)
                            )
                        );
                        $queryBuilder->orderBy($sortField, 'ASC');
                    }
                }
 
                $result = $queryBuilder->execute();
                if ($recordBefore = $result->fetch()) {
                    if ($afterUID) {
                        $dataHandlerCommands[$table][$uid]['move'] = -$afterUID;
                    } elseif ($direction === 'down') {
                        $dataHandlerCommands[$table][$uid]['move'] = -$recordBefore['uid'];
                    } elseif ($recordAfter = $result->fetch()) {
                        // Must take the second record above...
                        $dataHandlerCommands[$table][$uid]['move'] = -$recordAfter['uid'];
                    } else {
                        // ... and if that does not exist, use pid
                        $dataHandlerCommands[$table][$uid]['move'] = $currentRecord['pid'];
                    }
                } elseif ($direction === 'up') {
                    $dataHandlerCommands[$table][$uid]['move'] = $currentRecord['pid'];
                }
            }
 
            // If any data handler commands were set, execute the data handler command
            if (!empty($dataHandlerCommands)) {
                $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
                $dataHandler->start([], $dataHandlerCommands);
                $dataHandler->process_cmdmap();
            }
        }
    }
 
    protected function ‪doDelete(string $table, int $uid)
    {
        $cmdData[$table][$uid]['delete'] = 1;
        if (!empty($cmdData)) {
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            $dataHandler->start([], $cmdData);
            $dataHandler->process_cmdmap();
        }
    }
 
    protected function ‪doSave(string $table, int $uid)
    {
        $data = $this->configuration['data'];
        if (!empty($data)) {
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            $dataHandler->start($data, []);
            $dataHandler->process_uploads($_FILES);
            $dataHandler->process_datamap();
            // Save the new UID back into configuration
            $newUID = $dataHandler->substNEWwithIDs['NEW'];
            if ($newUID) {
                $this->configuration['newUID'] = $newUID;
            }
        }
    }
 
    protected function ‪doSaveAndClose(string $table, int $uid)
    {
        $this->‪doSave($table, $uid);
    }
 
    protected function ‪doClose(string $table, int $uid)
    {
    }
}