FileController.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\Controller\File;
 
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Backend\Attribute\Controller;
use ‪TYPO3\CMS\Backend\Clipboard\Clipboard;
use ‪TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException;
use ‪TYPO3\CMS\Backend\Routing\UriBuilder;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Http\HtmlResponse;
use ‪TYPO3\CMS\Core\Http\JsonResponse;
use ‪TYPO3\CMS\Core\Http\RedirectResponse;
use ‪TYPO3\CMS\Core\Imaging\IconFactory;
use TYPO3\CMS\Core\Imaging\IconSize;
use ‪TYPO3\CMS\Core\Messaging\FlashMessageService;
use ‪TYPO3\CMS\Core\Resource\DuplicationBehavior;
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\ContextualFeedbackSeverity;
use ‪TYPO3\CMS\Core\Utility\File\ExtendedFileUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
#[Controller]
class ‪FileController
{
    protected ‪$file;
 
    protected ‪$CB;
 
    protected ‪$overwriteExistingFiles;
 
    protected ‪$redirect;
 
    protected ‪$fileData;
 
    public function ‪__construct(
        protected readonly ‪ResourceFactory $fileFactory,
        protected readonly ‪ExtendedFileUtility $fileProcessor,
        protected readonly ‪IconFactory $iconFactory,
        protected readonly ‪UriBuilder $uriBuilder,
        protected readonly ‪FlashMessageService $flashMessageService
    ) {
    }
 
    public function ‪mainAction(ServerRequestInterface $request): ResponseInterface
    {
        $this->‪init($request);
        $this->‪main();
 
        BackendUtility::setUpdateSignal('updateFolderTree');
 
        // go and edit the new created file
        if ($request->getParsedBody()['edit'] ?? '') {
            ‪$file = $this->fileData['newfile'][0];
            if (‪$file !== null) {
                $this->redirect = $this->‪getFileEditRedirect(‪$file) ?? ‪$this->redirect;
            }
        }
        if ($this->redirect) {
            return new ‪RedirectResponse(
                GeneralUtility::locationHeaderUrl($this->redirect),
                303
            );
        }
        // empty response
        return new ‪HtmlResponse('');
    }
 
    public function ‪processAjaxRequest(ServerRequestInterface $request): ResponseInterface
    {
        $this->‪init($request);
        $this->‪main();
        $flatResult = [
            'hasErrors' => false,
        ];
        foreach ($this->fileData as $action => $results) {
            foreach ($results as $result) {
                if (is_array($result)) {
                    foreach ($result as $subResult) {
                        $flatResult[$action][] = $this->‪flattenResultDataValue($subResult);
                    }
                } else {
                    $flatResult[$action][] = $this->‪flattenResultDataValue($result);
                }
            }
        }
 
        // Used in the FileStorageTree when moving / copying folders, or in the DragUploader
        $messages = $this->flashMessageService->getMessageQueueByIdentifier()->getAllMessagesAndFlush();
        if (!empty($messages)) {
            foreach ($messages as $message) {
                $flatResult['messages'][] = [
                    'title'    => $message->getTitle(),
                    'message'  => $message->getMessage(),
                    'severity' => $message->getSeverity(),
                ];
                if ($message->getSeverity() === ContextualFeedbackSeverity::ERROR) {
                    $flatResult['hasErrors'] = true;
                }
            }
        }
        return new ‪JsonResponse($flatResult, $flatResult['hasErrors'] ? 500 : 200);
    }
 
    public function ‪fileExistsInFolderAction(ServerRequestInterface $request): ResponseInterface
    {
        $this->‪init($request);
        $fileName = $request->getParsedBody()['fileName'] ?? $request->getQueryParams()['fileName'] ?? null;
        $fileTarget = $request->getParsedBody()['fileTarget'] ?? $request->getQueryParams()['fileTarget'] ?? null;
 
        $fileTargetObject = $this->fileFactory->retrieveFileOrFolderObject($fileTarget);
        $processedFileName = $fileTargetObject->getStorage()->sanitizeFileName($fileName, $fileTargetObject);
 
        $result = [];
        if ($fileTargetObject->hasFile($processedFileName)) {
            $fileInFolder = $fileTargetObject->getStorage()->getFileInFolder($processedFileName, $fileTargetObject);
            if ($fileInFolder instanceof ‪File) {
                $result = $this->‪flattenFileResultDataValue($fileInFolder);
            }
        }
        return new ‪JsonResponse($result);
    }
 
    protected function ‪init(ServerRequestInterface $request): void
    {
        // Set the GPvars from outside
        $parsedBody = $request->getParsedBody();
        $queryParams = $request->getQueryParams();
        $this->file = (array)($parsedBody['data'] ?? $queryParams['data'] ?? []);
        $redirectUrl = (string)($parsedBody['redirect'] ?? $queryParams['redirect'] ?? '');
        if ($this->file === [] || $redirectUrl !== '') {
            // This in clipboard mode or when a new folder is created
            $this->redirect = GeneralUtility::sanitizeLocalUrl($redirectUrl);
        } else {
            $mode = key($this->file);
            $elementKey = key($this->file[$mode]);
            $this->redirect = GeneralUtility::sanitizeLocalUrl($this->file[$mode][$elementKey]['redirect'] ?? '');
        }
        $this->CB = (array)($parsedBody['CB'] ?? $queryParams['CB'] ?? []);
 
        if (isset($this->file['rename'][0]['conflictMode'])) {
            $conflictMode = $this->file['rename'][0]['conflictMode'];
            unset($this->file['rename'][0]['conflictMode']);
            $this->overwriteExistingFiles = ‪DuplicationBehavior::cast($conflictMode);
        } else {
            $this->overwriteExistingFiles = ‪DuplicationBehavior::cast($parsedBody['overwriteExistingFiles'] ?? $queryParams['overwriteExistingFiles'] ?? null);
        }
        $this->‪initClipboard($request);
    }
 
    protected function ‪initClipboard(ServerRequestInterface $request): void
    {
        if ($this->CB !== []) {
            $clipObj = GeneralUtility::makeInstance(Clipboard::class);
            $clipObj->initializeClipboard($request);
            if ($this->CB['paste'] ?? false) {
                $clipObj->setCurrentPad((string)($this->CB['pad'] ?? ''));
                $this->‪setPasteCmd($clipObj);
            }
            if ($this->CB['delete'] ?? false) {
                $clipObj->setCurrentPad((string)($this->CB['pad'] ?? ''));
                $this->‪setDeleteCmd($clipObj);
            }
        }
    }
 
    protected function ‪main(): void
    {
        $this->fileProcessor->setActionPermissions();
        $this->fileProcessor->setExistingFilesConflictMode($this->overwriteExistingFiles);
        $this->fileProcessor->start($this->file);
        $this->fileData = $this->fileProcessor->processData();
    }
 
    protected function ‪getFileEditRedirect(‪File ‪$file): ?string
    {
        if (!‪$file->isTextFile()) {
            return null;
        }
        ‪$properties = ‪$file->getProperties();
        $urlParameters = [
            'target' =>  ‪$properties['storage'] . ':' . ‪$properties['identifier'],
        ];
        if ($this->redirect) {
            $urlParameters['returnUrl'] = ‪$this->redirect;
        }
        try {
            return (string)$this->uriBuilder->buildUriFromRoute('file_edit', $urlParameters);
        } catch (RouteNotFoundException $exception) {
            // no route for editing files available
            return '';
        }
    }
 
    protected function ‪flattenFileResultDataValue(‪File $result): array
    {
        $thumbUrl = $result->‪isImage()
            ? ($result->‪process(‪ProcessedFile::CONTEXT_IMAGEPREVIEW, [])->getPublicUrl() ?? '')
            : '';
        $path = '';
        if (is_callable([$result->‪getParentFolder(), 'getReadablePath'])) {
            $path = $result->‪getParentFolder()->getReadablePath();
        }
        return array_merge(
            $result->toArray(),
            [
                'date' => BackendUtility::date($result->‪getModificationTime()),
                'icon' => $this->iconFactory->getIconForFileExtension($result->‪getExtension(), IconSize::SMALL)->render(),
                'thumbUrl' => $thumbUrl,
                'path' => $path,
            ]
        );
    }
 
    protected function ‪flattenResultDataValue($result)
    {
        if ($result instanceof File) {
            $result = $this->‪flattenFileResultDataValue($result);
        } elseif ($result instanceof Folder) {
            $result = $result->getIdentifier();
        }
 
        return $result;
    }
 
    protected function ‪setPasteCmd(‪Clipboard $clipboard): void
    {
        $target = explode('|', (string)$this->CB['paste'])[1] ?? '';
        $mode = $clipboard->‪currentMode() === 'copy' ? 'copy' : 'move';
        // Traverse elements and make CMD array
        foreach ($clipboard->‪elFromTable('_FILE') as $key => $path) {
            $this->file[$mode][] = ['data' => $path, 'target' => $target];
            if ($mode === 'move') {
                $clipboard->‪removeElement($key);
            }
        }
        $clipboard->‪endClipboard();
    }
 
    protected function ‪setDeleteCmd(‪Clipboard $clipObj): void
    {
        // Traverse elements and make CMD array
        foreach ($clipObj->‪elFromTable('_FILE') as $key => $path) {
            $this->file['delete'][] = ['data' => $path];
            $clipObj->‪removeElement($key);
        }
        $clipObj->‪endClipboard();
    }
}