[FEATURE] Add Dispatcher for Backend Routing 37/43337/13
authorBenjamin Mack <benni@typo3.org>
Tue, 15 Sep 2015 14:45:25 +0000 (16:45 +0200)
committerAndreas Fernandez <typo3@scripting-base.de>
Wed, 16 Sep 2015 12:22:17 +0000 (14:22 +0200)
The newly introduced Backend Routing is updated so that Routes
must define not just the controller but also the action which should
be called. It is now also possible to use a Closure / callable directly
to be called as a Route.

The RequestHandler now creates the Response object, which is
handed to the Dispatcher and to the respective action. This way
each action can already use the existing Response object.

The Dispatcher resolves the action and hands over the request and
response object.

All existing routes have been adapted to use controller and actions.

The fixed ControllerInterface is not needed anymore.

Resolves: #69855
Releases: master
Change-Id: I6edcf8e0f6b49580052f24ca9fd7ad352b6d6f34
Reviewed-on: http://review.typo3.org/43337
Reviewed-by: Nicole Cordes <typo3@cordes.co>
Tested-by: Nicole Cordes <typo3@cordes.co>
Reviewed-by: Andreas Fernandez <typo3@scripting-base.de>
Tested-by: Andreas Fernandez <typo3@scripting-base.de>
48 files changed:
typo3/sysext/backend/Classes/Controller/BackendController.php
typo3/sysext/backend/Classes/Controller/BackendLayoutWizardController.php
typo3/sysext/backend/Classes/Controller/ContentElement/ElementHistoryController.php
typo3/sysext/backend/Classes/Controller/ContentElement/ElementInformationController.php
typo3/sysext/backend/Classes/Controller/ContentElement/MoveElementController.php
typo3/sysext/backend/Classes/Controller/ContentElement/NewContentElementController.php
typo3/sysext/backend/Classes/Controller/DummyController.php
typo3/sysext/backend/Classes/Controller/EditDocumentController.php
typo3/sysext/backend/Classes/Controller/File/CreateFolderController.php
typo3/sysext/backend/Classes/Controller/File/EditFileController.php
typo3/sysext/backend/Classes/Controller/File/FileController.php
typo3/sysext/backend/Classes/Controller/File/FileUploadController.php
typo3/sysext/backend/Classes/Controller/File/RenameFileController.php
typo3/sysext/backend/Classes/Controller/File/ReplaceFileController.php
typo3/sysext/backend/Classes/Controller/FileSystemNavigationFrameController.php
typo3/sysext/backend/Classes/Controller/LoginController.php
typo3/sysext/backend/Classes/Controller/LoginFramesetController.php
typo3/sysext/backend/Classes/Controller/LogoutController.php
typo3/sysext/backend/Classes/Controller/NewRecordController.php
typo3/sysext/backend/Classes/Controller/OnlineMediaController.php
typo3/sysext/backend/Classes/Controller/SimpleDataHandlerController.php
typo3/sysext/backend/Classes/Controller/Wizard/AddController.php
typo3/sysext/backend/Classes/Controller/Wizard/ColorpickerController.php
typo3/sysext/backend/Classes/Controller/Wizard/EditController.php
typo3/sysext/backend/Classes/Controller/Wizard/ListController.php
typo3/sysext/backend/Classes/Controller/Wizard/RteController.php
typo3/sysext/backend/Classes/Controller/Wizard/TableController.php
typo3/sysext/backend/Classes/Http/Dispatcher.php [new file with mode: 0644]
typo3/sysext/backend/Classes/Http/RequestHandler.php
typo3/sysext/backend/Configuration/Backend/Routes.php
typo3/sysext/compatibility6/Classes/Controller/Wizard/FormsController.php
typo3/sysext/compatibility6/Configuration/Backend/Routes.php
typo3/sysext/core/Classes/Http/ControllerInterface.php
typo3/sysext/core/Classes/Http/DispatcherInterface.php [new file with mode: 0644]
typo3/sysext/core/Documentation/Changelog/master/Feature-69855-DispatcherForBackendRoutingAdded.rst [new file with mode: 0644]
typo3/sysext/impexp/Classes/Controller/ImportExportController.php
typo3/sysext/impexp/Configuration/Backend/Routes.php
typo3/sysext/openid/Classes/Wizard.php
typo3/sysext/openid/Configuration/Backend/Routes.php
typo3/sysext/recordlist/Classes/Controller/ElementBrowserController.php
typo3/sysext/recordlist/Classes/Controller/ElementBrowserFramesetController.php
typo3/sysext/recordlist/Configuration/Backend/Routes.php
typo3/sysext/rtehtmlarea/Classes/Controller/ParseHtmlController.php
typo3/sysext/rtehtmlarea/Classes/Controller/SpellCheckingController.php
typo3/sysext/rtehtmlarea/Classes/Controller/UserElementsController.php
typo3/sysext/rtehtmlarea/Configuration/Backend/Routes.php
typo3/sysext/version/Classes/Controller/VersionModuleController.php
typo3/sysext/version/Configuration/Backend/Routes.php

index 2a78829..750ed3e 100644 (file)
@@ -14,12 +14,12 @@ namespace TYPO3\CMS\Backend\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Backend\Domain\Repository\Module\BackendModuleRepository;
 use TYPO3\CMS\Backend\Module\ModuleLoader;
 use TYPO3\CMS\Backend\Toolbar\ToolbarItemInterface;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Page\PageRenderer;
 use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -30,7 +30,7 @@ use TYPO3\CMS\Rsaauth\RsaEncryptionEncoder;
 /**
  * Class for rendering the TYPO3 backend
  */
-class BackendController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class BackendController {
 
        /**
         * @var string
@@ -245,15 +245,13 @@ class BackendController implements \TYPO3\CMS\Core\Http\ControllerInterface {
        /**
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the render() method, it is rather simple for now
-        * This will be split up in an abstract controller once proper routing/dispatcher is in place.
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->render();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
index e2d0470..03aef60 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
@@ -31,7 +30,7 @@ use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
 /**
  * Script Class for grid wizard
  */
-class BackendLayoutWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class BackendLayoutWizardController {
 
        // GET vars:
        // Wizard parameters, coming from TCEforms linking to the wizard.
@@ -211,13 +210,11 @@ class BackendLayoutWizardController implements \TYPO3\CMS\Core\Http\ControllerIn
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->doc->render('Grid wizard', $this->content));
                return $response;
        }
@@ -271,7 +268,7 @@ class BackendLayoutWizardController implements \TYPO3\CMS\Core\Http\ControllerIn
         * Returns the sourcecode to the browser
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index d58b3ad..f431473 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\ContentElement;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -25,7 +24,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
  * Script Class for showing the history module of TYPO3s backend
  * @see \TYPO3\CMS\Backend\History\RecordHistory
  */
-class ElementHistoryController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ElementHistoryController {
 
        /**
         * @var string
@@ -58,17 +57,16 @@ class ElementHistoryController implements \TYPO3\CMS\Core\Http\ControllerInterfa
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
                $this->content .= $this->doc->endPage();
                $this->content = $this->doc->insertStylesAndJS($this->content);
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -109,7 +107,7 @@ class ElementHistoryController implements \TYPO3\CMS\Core\Http\ControllerInterfa
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index a6df5f4..287649a 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\ContentElement;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Imaging\Icon;
@@ -30,7 +29,7 @@ use TYPO3\CMS\Backend\Backend\Avatar\Avatar;
 /**
  * Script Class for showing information about an item.
  */
-class ElementInformationController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ElementInformationController {
 
        /**
         * Record table name
@@ -194,18 +193,17 @@ class ElementInformationController implements \TYPO3\CMS\Core\Http\ControllerInt
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
                $content = $this->doc->startPage($this->titleTag);
                $content .= $this->doc->insertStylesAndJS($this->content);
                $content .= $this->doc->endPage();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($content);
                return $response;
        }
@@ -540,7 +538,7 @@ class ElementInformationController implements \TYPO3\CMS\Core\Http\ControllerInt
         * End page and print content
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 99af37b..33f691e 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\ContentElement;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Imaging\Icon;
@@ -26,7 +25,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 /**
  * Script Class for rendering the move-element wizard display
  */
-class MoveElementController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class MoveElementController {
 
        /**
         * @var int
@@ -128,14 +127,13 @@ class MoveElementController implements \TYPO3\CMS\Core\Http\ControllerInterface
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -255,7 +253,7 @@ class MoveElementController implements \TYPO3\CMS\Core\Http\ControllerInterface
         * Print out the accumulated content:
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index fbe68e7..eada142 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\ContentElement;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Imaging\Icon;
@@ -27,7 +26,7 @@ use TYPO3\CMS\Core\Utility\PathUtility;
 /**
  * Script Class for the New Content element wizard
  */
-class NewContentElementController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class NewContentElementController {
 
        /**
         * Page id
@@ -165,14 +164,13 @@ class NewContentElementController implements \TYPO3\CMS\Core\Http\ControllerInte
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -324,7 +322,7 @@ class NewContentElementController implements \TYPO3\CMS\Core\Http\ControllerInte
         * Print out the accumulated content:
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index dd59e15..e0e3dc7 100644 (file)
@@ -16,13 +16,12 @@ namespace TYPO3\CMS\Backend\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
  * Script Class, creating the content for the dummy script - which is just blank output.
  */
-class DummyController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class DummyController {
 
        /**
         * @var string
@@ -40,14 +39,13 @@ class DummyController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -68,7 +66,7 @@ class DummyController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index dff00df..396bace 100644 (file)
@@ -14,14 +14,13 @@ namespace TYPO3\CMS\Backend\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Backend\Form\Exception\AccessDeniedException;
 use TYPO3\CMS\Backend\Form\FormResultCompiler;
 use TYPO3\CMS\Backend\Form\Utility\FormEngineUtility;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
-use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\DataHandling\DataHandler;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Messaging\FlashMessage;
@@ -41,7 +40,7 @@ use TYPO3\CMS\Backend\Form\FormDataGroup\TcaDatabaseRecord;
  * Script Class: Drawing the editing form for editing records in TYPO3.
  * Notice: It does NOT use tce_db.php to submit data to, rather it handles submissions itself
  */
-class EditDocumentController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class EditDocumentController {
 
        /**
         * GPvar "edit": Is an array looking approx like [tablename][list-of-ids]=command, eg.
@@ -1610,11 +1609,11 @@ class EditDocumentController implements \TYPO3\CMS\Core\Http\ControllerInterface
        /**
         * Injects the request object for the current request or subrequest
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
-
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                BackendUtility::lockRecords();
 
                // Preprocessing, storing data if submitted to
@@ -1628,8 +1627,6 @@ class EditDocumentController implements \TYPO3\CMS\Core\Http\ControllerInterface
                $this->init();
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
index 57a9d2e..276095d 100644 (file)
@@ -16,8 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\File;
 
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
-use TYPO3\CMS\Core\Http\ControllerInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Resource\Exception\InsufficientFolderAccessPermissionsException;
@@ -31,7 +29,7 @@ use TYPO3\CMS\Core\Utility\MathUtility;
 /**
  * Script Class for the create-new script; Displays a form for creating up to 10 folders or one new text file
  */
-class CreateFolderController implements ControllerInterface {
+class CreateFolderController {
 
        /**
         * @var int
@@ -304,13 +302,13 @@ class CreateFolderController implements ControllerInterface {
        /**
         * Processes the request, currently everything is handled and put together via "main()"
         *
-        * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -319,7 +317,7 @@ class CreateFolderController implements ControllerInterface {
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the processRequest() method instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the mainAction() method instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 497e542..706702c 100644 (file)
@@ -20,12 +20,11 @@ use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 
 /**
  * Script Class for rendering the file editing screen
  */
-class EditFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class EditFileController {
 
        /**
         * Module content accumulated.
@@ -214,13 +213,13 @@ class EditFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
        /**
         * Processes the request, currently everything is handled and put together via "main()"
         *
-        * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -229,7 +228,7 @@ class EditFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the processRequest() method instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the mainAction() method instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 8627cba..8ec7afe 100644 (file)
@@ -14,9 +14,9 @@ namespace TYPO3\CMS\Backend\Controller\File;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Core\Http\AjaxRequestHandler;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Resource\DuplicationBehavior;
 use TYPO3\CMS\Core\Resource\Folder;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -30,7 +30,7 @@ use TYPO3\CMS\Core\Utility\File\ExtendedFileUtility;
  * Before TYPO3 4.3, it was located in typo3/tce_file.php and redirected back to a
  * $redirectURL. Since 4.3 this class is also used for accessing via AJAX
  */
-class FileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class FileController {
 
        /**
         * Array of file-operations.
@@ -169,18 +169,17 @@ class FileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it just redirects to the given URL afterwards.
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
                // Push errors to flash message queue, if there are any
                $this->fileProcessor->pushErrorMessagesToFlashMessageQueue();
                BackendUtility::setUpdateSignal('updateFolderTree');
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                if ($this->redirect) {
                        $response = $response->withHeader('Location', GeneralUtility::locationHeaderUrl($this->redirect));
                        return $response->withStatus(303);
index d9050d3..ae6f8bf 100644 (file)
@@ -20,12 +20,11 @@ use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 
 /**
  * Script Class for display up to 10 upload fields
  */
-class FileUploadController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class FileUploadController {
 
        /**
         * Document template object
@@ -186,13 +185,13 @@ class FileUploadController implements \TYPO3\CMS\Core\Http\ControllerInterface {
        /**
         * Processes the request, currently everything is handled and put together via "main()"
         *
-        * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -201,7 +200,7 @@ class FileUploadController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the processRequest() method instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the mainAction() method instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 98ce1e2..932a13c 100644 (file)
@@ -20,12 +20,11 @@ use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 
 /**
  * Script Class for the rename-file form.
  */
-class RenameFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class RenameFileController {
 
        /**
         * Document template object
@@ -184,13 +183,13 @@ class RenameFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
        /**
         * Processes the request, currently everything is handled and put together via "main()"
         *
-        * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -199,7 +198,7 @@ class RenameFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the processRequest() method instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the mainAction() method instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index d032889..174eda1 100644 (file)
@@ -25,12 +25,11 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Lang\LanguageService;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 
 /**
  * Script Class for the rename-file form
  */
-class ReplaceFileController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ReplaceFileController {
 
        /**
         * Document template object
@@ -210,13 +209,13 @@ class ReplaceFileController implements \TYPO3\CMS\Core\Http\ControllerInterface
        /**
         * Processes the request, currently everything is handled and put together via "main()"
         *
-        * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -225,7 +224,7 @@ class ReplaceFileController implements \TYPO3\CMS\Core\Http\ControllerInterface
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the processRequest() method instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use the mainAction() method instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 8bcb533..a05e8e6 100644 (file)
@@ -14,11 +14,9 @@ namespace TYPO3\CMS\Backend\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
-use TYPO3\CMS\Core\Http\Response;
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Backend\Tree\View\ElementBrowserFolderTreeView;
-use TYPO3\CMS\Backend\Utility\IconUtility;
-use TYPO3\CMS\Core\Http\ControllerInterface;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -30,7 +28,7 @@ use TYPO3\CMS\Recordlist\Browser\ElementBrowser;
 /**
  * Main script class for rendering of the folder tree
  */
-class FileSystemNavigationFrameController implements ControllerInterface {
+class FileSystemNavigationFrameController {
 
        /**
         * Content accumulates in this variable.
@@ -80,14 +78,14 @@ class FileSystemNavigationFrameController implements ControllerInterface {
        }
 
        /**
-        * @param ServerRequestInterface $request
-        * @return Response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->initPage();
                $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+
                $response->getBody()->write($this->content);
                return $response;
        }
index ce7ddbf..f3d9cb4 100644 (file)
@@ -14,6 +14,7 @@ namespace TYPO3\CMS\Backend\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Backend\Exception;
 use TYPO3\CMS\Backend\LoginProvider\LoginProviderInterface;
@@ -21,7 +22,6 @@ use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
 use TYPO3\CMS\Core\FormProtection\BackendFormProtection;
 use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Page\PageRenderer;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Core\Utility\HttpUtility;
@@ -31,7 +31,7 @@ use TYPO3\CMS\Fluid\View\StandaloneView;
 /**
  * Script Class for rendering the login form
  */
-class LoginController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class LoginController {
 
        /**
         * The URL to redirect to after login.
@@ -122,17 +122,15 @@ class LoginController implements \TYPO3\CMS\Core\Http\ControllerInterface {
        }
 
        /**
-        * Injects the request object for the current request or subrequest
+        * Injects the request and response objects for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
-        * This will be split up in an abstract controller once proper routing/dispatcher is in place.
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response the current response
+        * @return ResponseInterface the finished response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function formAction(ServerRequestInterface $request, ResponseInterface $response) {
                $content = $this->main();
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($content);
                return $response;
        }
index 817196e..44b7aa5 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Page\PageRenderer;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -24,7 +23,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 /**
  * Script Class, putting the frameset together.
  */
-class LoginFramesetController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class LoginFramesetController {
 
        /**
         * @var string
@@ -43,13 +42,11 @@ class LoginFramesetController implements \TYPO3\CMS\Core\Http\ControllerInterfac
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -77,7 +74,7 @@ class LoginFramesetController implements \TYPO3\CMS\Core\Http\ControllerInterfac
         * Outputs the page content.
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index de86d3c..14fd6d7 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller;
 
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
 
@@ -24,17 +23,18 @@ use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
  * Script Class for logging a user out.
  * Does not display any content, just calls the logout-function for the current user and then makes a redirect.
  */
-class LogoutController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class LogoutController {
 
        /**
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         * This will be split up in an abstract controller once proper routing/dispatcher is in place.
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function logoutAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->logout();
 
                $redirectUrl = isset($request->getParsedBody()['redirect']) ? $request->getParsedBody()['redirect'] : $request->getQueryParams()['redirect'];
@@ -44,10 +44,9 @@ class LogoutController implements \TYPO3\CMS\Core\Http\ControllerInterface {
                        $uriBuilder = GeneralUtility::makeInstance(\TYPO3\CMS\Backend\Routing\UriBuilder::class);
                        $redirectUrl = (string)$uriBuilder->buildUriFromRoute('login', array(), $uriBuilder::ABSOLUTE_URL);
                }
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
-               $response =     $response->withHeader('Location', GeneralUtility::locationHeaderUrl($redirectUrl));
-               return $response->withStatus(303);
+               return $response
+                       ->withStatus(303)
+                       ->withHeader('Location', GeneralUtility::locationHeaderUrl($redirectUrl));
        }
 
        /**
index 7359986..596380a 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Database\DatabaseConnection;
@@ -34,7 +33,7 @@ use TYPO3\CMS\Frontend\Page\PageRepository;
 /**
  * Script class for 'db_new'
  */
-class NewRecordController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class NewRecordController {
 
        /**
         * @var array
@@ -233,14 +232,13 @@ class NewRecordController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -573,7 +571,7 @@ class NewRecordController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Ending page output and echo'ing content to browser.
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index a7ccade..48d1374 100644 (file)
@@ -15,7 +15,6 @@ namespace TYPO3\CMS\Backend\Controller;
  */
 
 use TYPO3\CMS\Core\Http\AjaxRequestHandler;
-use TYPO3\CMS\Core\Http\ControllerInterface;
 use TYPO3\CMS\Core\Messaging\FlashMessage;
 use TYPO3\CMS\Core\Messaging\FlashMessageService;
 use TYPO3\CMS\Core\Resource\OnlineMedia\Helpers\OnlineMediaHelperRegistry;
@@ -25,12 +24,11 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Lang\LanguageService;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 
 /**
  * Class OnlineMediaController handles uploading online media
  */
-class OnlineMediaController implements ControllerInterface {
+class OnlineMediaController {
 
        /**
         * @param array $_
@@ -58,9 +56,10 @@ class OnlineMediaController implements ControllerInterface {
         * Process add media request
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $files = $request->getParsedBody()['file'];
                $newMedia = [];
                if (isset($files['newMedia'])) {
@@ -92,8 +91,6 @@ class OnlineMediaController implements ControllerInterface {
                        }
                }
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $redirect = isset($request->getParsedBody()['redirect']) ? $request->getParsedBody()['redirect'] : $request->getQueryParams()['redirect'];
                if ($redirect) {
                        $response = $response
index 819915a..808e387 100644 (file)
@@ -14,8 +14,8 @@ namespace TYPO3\CMS\Backend\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Messaging\AbstractMessage;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Core\DataHandling\DataHandler;
@@ -34,7 +34,7 @@ use TYPO3\CMS\Core\Messaging\FlashMessageService;
  * Is not used by FormEngine though (main form rendering script) - that uses the same class (TCEmain) but makes its own initialization (to save the redirect request).
  * For all other cases than FormEngine it is recommended to use this script for submitting your editing forms - but the best solution in any case would probably be to link your application to FormEngine, that will give you easy form-rendering as well.
  */
-class SimpleDataHandlerController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class SimpleDataHandlerController {
 
        /**
         * Array. Accepts options to be set in TCE object. Currently it supports "reverseOrder" (bool).
@@ -244,10 +244,11 @@ class SimpleDataHandlerController implements \TYPO3\CMS\Core\Http\ControllerInte
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it just redirects to the given URL afterwards.
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->initClipboard();
                $this->main();
 
@@ -255,15 +256,12 @@ class SimpleDataHandlerController implements \TYPO3\CMS\Core\Http\ControllerInte
                if ($this->prErr) {
                        $this->tce->printLogErrorMessages($this->redirect);
                }
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                if ($this->redirect) {
-                       $response = $response->withHeader('Location', GeneralUtility::locationHeaderUrl($this->redirect));
-                       return $response->withStatus(303);
-               } else {
-                       // empty response
-                       return $response;
+                       $response = $response
+                               ->withHeader('Location', GeneralUtility::locationHeaderUrl($this->redirect))
+                               ->withStatus(303);
                }
+               return $response;
        }
 
        /**
index a2fe021..542b950 100644 (file)
@@ -19,7 +19,6 @@ use Psr\Http\Message\ResponseInterface;
 use TYPO3\CMS\Backend\Form\FormDataCompiler;
 use TYPO3\CMS\Backend\Form\FormDataGroup\OnTheFly;
 use TYPO3\CMS\Backend\Form\FormDataProvider\DatabaseEditRow;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Configuration\FlexForm\FlexFormTools;
 use TYPO3\CMS\Core\DataHandling\DataHandler;
@@ -31,7 +30,7 @@ use TYPO3\CMS\Core\Utility\MathUtility;
  * Script Class for adding new items to a group/select field. Performs proper redirection as needed.
  * Script is typically called after new child record was added and then adds the new child to select value of parent.
  */
-class AddController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class AddController extends AbstractWizardController {
 
        /**
         * Content accumulation for the module.
@@ -148,13 +147,11 @@ class AddController extends AbstractWizardController implements \TYPO3\CMS\Core\
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                return $response;
        }
 
index 5199bf2..b609f05 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\Wizard;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Page\PageRenderer;
@@ -25,7 +24,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 /**
  * Script Class for colorpicker wizard
  */
-class ColorpickerController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ColorpickerController extends AbstractWizardController {
 
        /**
         * Wizard parameters, coming from FormEngine linking to the wizard.
@@ -202,16 +201,15 @@ class ColorpickerController extends AbstractWizardController implements \TYPO3\C
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
                $this->content .= $this->doc->endPage();
                $this->content = $this->doc->insertStylesAndJS($this->content);
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -274,7 +272,7 @@ class ColorpickerController extends AbstractWizardController implements \TYPO3\C
         * Returns the sourcecode to the browser
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index e9c6288..0a5ae6b 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\Wizard;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Database\RelationHandler;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -25,7 +24,7 @@ use TYPO3\CMS\Core\Utility\HttpUtility;
 /**
  * Script Class for redirecting a backend user to the editing form when an "Edit wizard" link was clicked in FormEngine somewhere
  */
-class EditController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class EditController extends AbstractWizardController {
 
        /**
         * Wizard parameters, coming from FormEngine linking to the wizard.
@@ -74,13 +73,11 @@ class EditController extends AbstractWizardController implements \TYPO3\CMS\Core
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $content = $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($content);
                return $response;
        }
index 2616c23..908b51e 100644 (file)
@@ -16,14 +16,13 @@ namespace TYPO3\CMS\Backend\Controller\Wizard;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
  * Script Class for redirecting the user to the Web > List module if a wizard-link has been clicked in FormEngine
  */
-class ListController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ListController extends AbstractWizardController {
 
        /**
         * @var int
@@ -67,13 +66,11 @@ class ListController extends AbstractWizardController implements \TYPO3\CMS\Core
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                return $response;
        }
 
index b5eaf65..8a84de0 100644 (file)
@@ -20,13 +20,10 @@ use TYPO3\CMS\Backend\Form\FormDataCompiler;
 use TYPO3\CMS\Backend\Form\FormDataGroup\TcaDatabaseRecord;
 use TYPO3\CMS\Backend\Form\FormResultCompiler;
 use TYPO3\CMS\Backend\Form\NodeFactory;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Form\DataPreprocessor;
 use TYPO3\CMS\Backend\Form\FormEngine;
-use TYPO3\CMS\Backend\Form\Utility\FormEngineUtility;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
-use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -34,7 +31,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
 /**
  * Script class for rendering the full screen RTE display
  */
-class RteController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class RteController extends AbstractWizardController {
 
        /**
         * Document template object
@@ -120,13 +117,12 @@ class RteController extends AbstractWizardController implements \TYPO3\CMS\Core\
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -228,7 +224,7 @@ class RteController extends AbstractWizardController implements \TYPO3\CMS\Core\
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index b3ae886..2e80fd0 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Backend\Controller\Wizard;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Backend\Utility\IconUtility;
@@ -32,7 +31,7 @@ use TYPO3\CMS\Core\Utility\StringUtility;
 /**
  * Script Class for rendering the Table Wizard
  */
-class TableController extends AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class TableController extends AbstractWizardController {
 
        /**
         * Document template object
@@ -153,13 +152,11 @@ class TableController extends AbstractWizardController implements \TYPO3\CMS\Cor
         * As this controller goes only through the main() method, it is rather simple for now
         *
         * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ResponseInterface $response
+        * @return ResponseInterface
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -190,7 +187,7 @@ class TableController extends AbstractWizardController implements \TYPO3\CMS\Cor
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
diff --git a/typo3/sysext/backend/Classes/Http/Dispatcher.php b/typo3/sysext/backend/Classes/Http/Dispatcher.php
new file mode 100644 (file)
index 0000000..4d54f16
--- /dev/null
@@ -0,0 +1,117 @@
+<?php
+namespace TYPO3\CMS\Backend\Http;
+
+/*
+ * 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\Routing\Router;
+use TYPO3\CMS\Backend\Routing\Route;
+use TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException;
+use TYPO3\CMS\Core\Http\DispatcherInterface;
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
+
+/**
+ * Dispatcher which resolves a route to call a controller and method (but also a callable)
+ */
+class Dispatcher implements DispatcherInterface {
+
+       /**
+        * Main method to resolve the route and checks the target of the route, and tries to call it.
+        *
+        * @param ServerRequestInterface $request the current server request
+        * @param ResponseInterface $response the prepared response
+        * @return ResponseInterface the filled response by the callable / controller/action
+        * @throws RouteNotFoundException if the route was not found
+        * @throws \InvalidArgumentException if the defined target for the route is invalid
+        */
+       public function dispatch(ServerRequestInterface $request, ResponseInterface $response) {
+               /** @var Route $route */
+               $router = GeneralUtility::makeInstance(Router::class);
+               $route = $router->matchRequest($request);
+               $request = $request->withAttribute('route', $route);
+               if (!$this->isValidRequest($request)) {
+                       throw new RouteNotFoundException('Invalid request for route "' . $route->getPath() . '"', 1425389455);
+               }
+
+               $targetIdentifier = $route->getOption('target');
+               $target = $this->getCallableFromTarget($targetIdentifier);
+               return call_user_func_array($target, array($request, $response));
+       }
+
+       /**
+        * Wrapper method for static form protection utility
+        *
+        * @return \TYPO3\CMS\Core\FormProtection\AbstractFormProtection
+        */
+       protected function getFormProtection() {
+               return FormProtectionFactory::get();
+       }
+
+       /**
+        * Checks if the request token is valid. This is checked to see if the route is really
+        * created by the same instance. Should be called for all routes in the backend except
+        * for the ones that don't require a login.
+        *
+        * @param \Psr\Http\Message\ServerRequestInterface $request
+        * @return bool
+        * @see \TYPO3\CMS\Backend\Routing\UriBuilder where the token is generated.
+        */
+       protected function isValidRequest($request) {
+               $token = (string)(isset($request->getParsedBody()['token']) ? $request->getParsedBody()['token'] : $request->getQueryParams()['token']);
+               $route = $request->getAttribute('route');
+               return ($route->getOption('access') === 'public' || $this->getFormProtection()->validateToken($token, 'route', $route->getOption('_identifier')));
+       }
+
+       /**
+        * Creates a callable out of the given parameter, which can be a string, a callable / closure or an array
+        * which can be handed to call_user_func_array()
+        *
+        * @param array|string|callable $target the target which is being resolved.
+        * @return callable
+        * @throws \InvalidArgumentException
+        */
+       protected function getCallableFromTarget($target) {
+               if (is_array($target)) {
+                       return $target;
+               }
+
+               if (is_object($target) && $target instanceof \Closure) {
+                       return $target;
+               }
+
+               // Only a class name is given
+               if (is_string($target) && strpos($target, ':') === FALSE) {
+                       $target = GeneralUtility::makeInstance($target);
+                       if (method_exists($target, '__invoke')) {
+                               return $target;
+                       }
+               }
+
+               // Check if the target is a concatenated string of "className::actionMethod"
+               if (is_string($target) && strpos($target, '::') !== FALSE) {
+                       list($className, $methodName) = explode('::', $target, 2);
+                       $targetObject = GeneralUtility::makeInstance($className);
+                       return [$targetObject, $methodName];
+               }
+
+               // This needs to be checked at last as a string with object::method is recognize as callable
+               if (is_callable($target)) {
+                       return $target;
+               }
+
+               throw new \InvalidArgumentException('Invalid target for "' . $target. '", as it is not callable.', 1425381442);
+       }
+}
\ No newline at end of file
index f2f030b..c716f27 100644 (file)
@@ -14,13 +14,13 @@ namespace TYPO3\CMS\Backend\Http;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Core\Core\Bootstrap;
 use TYPO3\CMS\Core\Http\RequestHandlerInterface;
 use TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException;
-use TYPO3\CMS\Core\FormProtection\FormProtectionFactory;
+use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
-use TYPO3\CMS\Backend\Routing\Router;
-use TYPO3\CMS\Backend\Routing\Route;
 
 /**
  * General RequestHandler for the TYPO3 Backend. This is used for all Backend requests except for CLI
@@ -60,10 +60,10 @@ class RequestHandler implements RequestHandlerInterface {
        /**
         * Handles any backend request
         *
-        * @param \Psr\Http\Message\ServerRequestInterface $request
-        * @return NULL|\Psr\Http\Message\ResponseInterface
+        * @param ServerRequestInterface $request
+        * @return NULL|ResponseInterface
         */
-       public function handleRequest(\Psr\Http\Message\ServerRequestInterface $request) {
+       public function handleRequest(ServerRequestInterface $request) {
                // enable dispatching via Request/Response logic only for typo3/index.php
                // This fallback will be removed in TYPO3 CMS 8, as only index.php will be allowed
                $path = substr($request->getUri()->getPath(), strlen(GeneralUtility::getIndpEnv('TYPO3_SITE_PATH')));
@@ -122,10 +122,10 @@ class RequestHandler implements RequestHandlerInterface {
        /**
         * This request handler can handle any backend request (but not CLI).
         *
-        * @param \Psr\Http\Message\ServerRequestInterface $request
+        * @param ServerRequestInterface $request
         * @return bool If the request is not a CLI script, TRUE otherwise FALSE
         */
-       public function canHandleRequest(\Psr\Http\Message\ServerRequestInterface $request) {
+       public function canHandleRequest(ServerRequestInterface $request) {
                return (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_BE && !(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI));
        }
 
@@ -140,50 +140,18 @@ class RequestHandler implements RequestHandlerInterface {
        }
 
        /**
-        * Wrapper method for static form protection utility
+        * Dispatch the request to the appropriate controller through the Backend Dispatcher which resolves the routing
         *
-        * @return \TYPO3\CMS\Core\FormProtection\AbstractFormProtection
-        */
-       protected function getFormProtection() {
-               return FormProtectionFactory::get();
-       }
-
-       /**
-        * Checks if the request token is valid. This is checked to see if the route is really
-        * created by the same instance. Should be called for all routes in the backend except
-        * for the ones that don't require a login.
-        *
-        * @param \Psr\Http\Message\ServerRequestInterface $request
-        * @return bool
-        * @see \TYPO3\CMS\Backend\Routing\UriBuilder where the token is generated.
-        */
-       protected function isValidRequest($request) {
-               $token = (string)(isset($request->getParsedBody()['token']) ? $request->getParsedBody()['token'] : $request->getQueryParams()['token']);
-               $route = $request->getAttribute('route');
-               return ($route->getOption('access') === 'public' || $this->getFormProtection()->validateToken($token, 'route', $route->getOption('_identifier')));
-       }
-
-       /**
-        * Dispatch the request to the appropriate controller
-        *
-        * @param \Psr\Http\Message\ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface
+        * @param ServerRequestInterface $request
+        * @return ResponseInterface
         * @throws RouteNotFoundException when no route is registered
-        * @throws \RuntimeException when a route is found but the controller to be called does not implement the Controller Interface
+        * @throws \InvalidArgumentException when a route is found but the target of the route cannot be called
         */
        protected function dispatch($request) {
-               /** @var Route $route */
-               $router = GeneralUtility::makeInstance(Router::class);
-               $route = $router->matchRequest($request);
-               $request = $request->withAttribute('route', $route);
-               if (!$this->isValidRequest($request)) {
-                       throw new RouteNotFoundException('Invalid request for route "' . $route->getPath() . '"', 1425389455);
-               }
-               $className = $route->getOption('controller');
-               $controller = GeneralUtility::makeInstance($className);
-               if (!$controller instanceof \TYPO3\CMS\Core\Http\ControllerInterface) {
-                       throw new \RuntimeException('Requested controller "' . $className . '" does not implement the ControllerInterface', 1425389452);
-               }
-               return $controller->processRequest($request);
+               /** @var Response $response */
+               $response = GeneralUtility::makeInstance(Response::class);
+               /** @var Dispatcher $dispatcher */
+               $dispatcher = GeneralUtility::makeInstance(Dispatcher::class);
+               return $dispatcher->dispatch($request, $response);
        }
 }
index 0b287a0..6d704f7 100644 (file)
@@ -10,76 +10,74 @@ use TYPO3\CMS\Backend\Controller;
  *
  * Currently the "access" property is only used so no token creation + validation is made,
  * but will be extended further.
- *
- * @internal This is not a public API yet until TYPO3 CMS 7 LTS.
  */
 return [
        // Login screen of the TYPO3 Backend
        'login' => [
                'path' => '/login',
                'access' => 'public',
-               'controller' => Controller\LoginController::class
+               'target' => Controller\LoginController::class . '::formAction'
        ],
 
-       // Main backend rendering setup (backend.php) for the TYPO3 Backend
+       // Main backend rendering setup (previously called backend.php) for the TYPO3 Backend
        'main' => [
                'path' => '/main',
-               'controller' => Controller\BackendController::class
+               'target' => Controller\BackendController::class . '::mainAction'
        ],
 
        // Logout script for the TYPO3 Backend
        'logout' => [
                'path' => '/logout',
-               'controller' => Controller\LogoutController::class
+               'target' => Controller\LogoutController::class . '::logoutAction'
        ],
 
        // Register login frameset
        'login_frameset' => [
                'path' => '/login/frame',
-               'controller' => Controller\LoginFramesetController::class
+               'target' => Controller\LoginFramesetController::class . '::mainAction'
        ],
 
        /** Wizards */
        // Register backend_layout wizard
        'wizard_backend_layout' => [
                'path' => '/wizard/backend_layout',
-               'controller' => Controller\BackendLayoutWizardController::class
+               'target' => Controller\BackendLayoutWizardController::class . '::mainAction'
        ],
 
        // Register colorpicker wizard
        'wizard_colorpicker' => [
                'path' => '/wizard/colorpicker',
-               'controller' => Controller\Wizard\ColorpickerController::class
+               'target' => Controller\Wizard\ColorpickerController::class . '::mainAction'
        ],
 
        // Register table wizard
        'wizard_table' => [
                'path' => '/wizard/table',
-               'controller' => Controller\Wizard\TableController::class
+               'target' => Controller\Wizard\TableController::class . '::mainAction'
        ],
 
        // Register rte wizard
        'wizard_rte' => [
                'path' => '/wizard/rte',
-               'controller' => Controller\Wizard\RteController::class
+               'target' => Controller\Wizard\RteController::class . '::mainAction'
        ],
 
        // Register add wizard
        'wizard_add' => [
                'path' => '/wizard/add',
-               'controller' => Controller\Wizard\AddController::class
+               'target' => Controller\Wizard\AddController::class . '::mainAction'
        ],
 
        // Register list wizard
        'wizard_list' => [
                'path' => '/wizard/list',
-               'controller' => Controller\Wizard\ListController::class
+               'target' => Controller\Wizard\ListController::class . '::mainAction'
        ],
 
        // Register edit wizard
        'wizard_edit' => [
                'path' => '/wizard/edit',
-               'controller' => Controller\Wizard\EditController::class
+               'target' => Controller\Wizard\EditController::class . '::mainAction'
        ],
 
 
@@ -88,86 +86,86 @@ return [
        // File navigation tree
        'file_navframe' => [
                'path' => '/folder/tree',
-               'controller' => Controller\FileSystemNavigationFrameController::class
+               'target' => Controller\FileSystemNavigationFrameController::class . '::mainAction'
        ],
 
        // Editing the contents of a file
        'file_edit' => [
                'path' => '/file/editcontent',
-               'controller' => Controller\File\EditFileController::class
+               'target' => Controller\File\EditFileController::class . '::mainAction'
        ],
 
        // Create a new folder
        'file_newfolder' => [
                'path' => '/file/new',
-               'controller' => Controller\File\CreateFolderController::class
+               'target' => Controller\File\CreateFolderController::class . '::mainAction'
        ],
 
        // Rename a file
        'file_rename' => [
                'path' => '/file/rename',
-               'controller' => Controller\File\RenameFileController::class
+               'target' => Controller\File\RenameFileController::class . '::mainAction'
        ],
 
        // Replace a file with a different one
        'file_replace' => [
                'path' => '/file/replace',
-               'controller' => Controller\File\ReplaceFileController::class
+               'target' => Controller\File\ReplaceFileController::class . '::mainAction'
        ],
 
        // Upload new files
        'file_upload' => [
                'path' => '/file/upload',
-               'controller' => Controller\File\FileUploadController::class
+               'target' => Controller\File\FileUploadController::class . '::mainAction'
        ],
 
        // Add new online media
        'online_media' => [
                'path' => '/online-media',
-               'controller' => Controller\OnlineMediaController::class
+               'target' => Controller\OnlineMediaController::class . '::mainAction'
        ],
 
        /** DB Records-related routes */
        // Register record history module
        'record_history' => [
                'path' => '/record/history',
-               'controller' => Controller\ContentElement\ElementHistoryController::class
+               'target' => Controller\ContentElement\ElementHistoryController::class . '::mainAction'
        ],
 
        // Register new record
        'db_new' => [
                'path' => '/record/new',
-               'controller' => Controller\NewRecordController::class
+               'target' => Controller\NewRecordController::class . '::mainAction'
        ],
 
        // Register new content element module
        'new_content_element' => [
                'path' => '/record/content/new',
-               'controller' => Controller\ContentElement\NewContentElementController::class
+               'target' => Controller\ContentElement\NewContentElementController::class . '::mainAction'
        ],
 
        // Register move element module
        'move_element' => [
                'path' => '/record/move',
-               'controller' => Controller\ContentElement\MoveElementController::class
+               'target' => Controller\ContentElement\MoveElementController::class . '::mainAction'
        ],
 
        // Register show item module
        'show_item' => [
                'path' => '/record/info',
-               'controller' => Controller\ContentElement\ElementInformationController::class
+               'target' => Controller\ContentElement\ElementInformationController::class . '::mainAction'
        ],
 
        // Register browser
        'browser' => [
                'path' => '/record/browse',
-               'controller' => \TYPO3\CMS\Recordlist\Controller\ElementBrowserFramesetController::class
+               'target' => \TYPO3\CMS\Recordlist\Controller\ElementBrowserFramesetController::class . '::mainAction'
        ],
 
        // Dummy document - displays nothing but background color.
        'dummy' => [
                'path' => '/empty',
-               'controller' => Controller\DummyController::class
+               'target' => Controller\DummyController::class . '::mainAction'
        ],
 
        /** TYPO3 Core Engine-related routes */
@@ -179,7 +177,7 @@ return [
         */
        'tce_db' => [
                'path' => '/record/commit',
-               'controller' => Controller\SimpleDataHandlerController::class
+               'target' => Controller\SimpleDataHandlerController::class . '::mainAction'
        ],
 
        /**
@@ -191,7 +189,7 @@ return [
         */
        'tce_file' => [
                'path' => '/file/commit',
-               'controller' => Controller\File\FileController::class
+               'target' => Controller\File\FileController::class . '::mainAction'
        ],
 
        /**
@@ -201,6 +199,6 @@ return [
         */
        'record_edit' => [
                'path' => '/record/edit',
-               'controller' => Controller\EditDocumentController::class
+               'target' => Controller\EditDocumentController::class . '::mainAction'
        ],
 ];
index a8b66fe..258636a 100644 (file)
@@ -16,9 +16,7 @@ namespace TYPO3\CMS\Compatibility6\Controller\Wizard;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
-use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
@@ -110,7 +108,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
  *
  * The XML/phpArray structure is the internal format of the wizard.
  */
-class FormsController extends \TYPO3\CMS\Backend\Controller\Wizard\AbstractWizardController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class FormsController extends \TYPO3\CMS\Backend\Controller\Wizard\AbstractWizardController {
 
        /**
         * document template object
@@ -203,14 +201,13 @@ class FormsController extends \TYPO3\CMS\Backend\Controller\Wizard\AbstractWizar
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -241,7 +238,7 @@ class FormsController extends \TYPO3\CMS\Backend\Controller\Wizard\AbstractWizar
         * Outputting the accumulated content to screen
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index dfed485..4edb566 100644 (file)
@@ -6,6 +6,6 @@ return [
        // Register wizard
        'wizard_forms' => [
                'path' => '/wizard/forms',
-               'controller' => \TYPO3\CMS\Compatibility6\Controller\Wizard\FormsController::class
+               'target' => \TYPO3\CMS\Compatibility6\Controller\Wizard\FormsController::class . '::mainAction'
        ]
 ];
index 3601ac0..96564e4 100644 (file)
@@ -29,7 +29,7 @@ interface ControllerInterface {
         * Processes a typical request.
         *
         * @param ServerRequestInterface $request The request object
-        * @return ResponseInterface $response The response, created by the controller
+        * @return ResponseInterface The response, created by the controller
         * @api
         */
        public function processRequest(ServerRequestInterface $request);
diff --git a/typo3/sysext/core/Classes/Http/DispatcherInterface.php b/typo3/sysext/core/Classes/Http/DispatcherInterface.php
new file mode 100644 (file)
index 0000000..4416975
--- /dev/null
@@ -0,0 +1,35 @@
+<?php
+namespace TYPO3\CMS\Core\Http;
+
+/*
+ * 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;
+
+/**
+ * An interface for dispatcher that delegate requests/responses to a certain callable, typically a
+ * controller / action combination.
+ *
+ * Is usually called from the RequestHandler,
+ */
+interface DispatcherInterface {
+
+       /**
+        * Main method to dispatch a request and its response to a callable object
+        *
+        * @param ServerRequestInterface $request
+        * @param ResponseInterface $response
+        * @return ResponseInterface
+        */
+       public function dispatch(ServerRequestInterface $request, ResponseInterface $response);
+}
\ No newline at end of file
diff --git a/typo3/sysext/core/Documentation/Changelog/master/Feature-69855-DispatcherForBackendRoutingAdded.rst b/typo3/sysext/core/Documentation/Changelog/master/Feature-69855-DispatcherForBackendRoutingAdded.rst
new file mode 100644 (file)
index 0000000..6403e52
--- /dev/null
@@ -0,0 +1,27 @@
+======================================================
+Feature: #69855 - Dispatcher for Backend Routing added
+======================================================
+
+Description
+===========
+
+The previously introduced Backend Routing is updated so that Routes must be defined with a class name and method name,
+or a Closure / callable. The controller/action or closure is now named as "target".
+
+Example from EXT:backend/Configuration/Backend/Routes.php
+
+.. code-block:: php
+
+       // Logout script for the TYPO3 Backend
+       'logout' => [
+               'path' => '/logout',
+               'target' => Controller\LogoutController::class . '::logoutAction'
+       ]
+
+
+Impact
+======
+
+Each method that is registered will receive both the Request object and the Response object which can be manipulated for output.
+
+The fixed ControllerInterface is not needed anymore and will be removed.
\ No newline at end of file
index bf2284d..43ae0fc 100644 (file)
@@ -14,10 +14,10 @@ namespace TYPO3\CMS\Impexp\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Backend\Utility\IconUtility;
 use TYPO3\CMS\Core\Database\DatabaseConnection;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Messaging\FlashMessage;
@@ -33,7 +33,7 @@ use TYPO3\CMS\Lang\LanguageService;
 /**
  * Main script class for the Import / Export facility
  */
-class ImportExportController extends \TYPO3\CMS\Backend\Module\BaseScriptClass implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ImportExportController extends \TYPO3\CMS\Backend\Module\BaseScriptClass {
 
        /**
         * @var array|\TYPO3\CMS\Core\Resource\File[]
@@ -205,16 +205,15 @@ class ImportExportController extends \TYPO3\CMS\Backend\Module\BaseScriptClass i
         *
         * external_ref[tables][]=table/_ALL
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $GLOBALS['SOBE'] = $this;
                $this->init();
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
index 84c64a9..570b2d5 100644 (file)
@@ -7,6 +7,6 @@ return [
        // Register click menu entry point
        'xMOD_tximpexp' => [
                'path' => '/record/importexport/',
-               'controller' => \TYPO3\CMS\Impexp\Controller\ImportExportController::class
+               'target' => \TYPO3\CMS\Impexp\Controller\ImportExportController::class . '::mainAction'
        ]
 ];
index 2bc5972..01b0f44 100644 (file)
@@ -15,7 +15,6 @@ namespace TYPO3\CMS\Openid;
  */
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Messaging\FlashMessage;
 use TYPO3\CMS\Core\Messaging\FlashMessageService;
@@ -27,7 +26,7 @@ use TYPO3\CMS\Lang\LanguageService;
 /**
  * OpenID selection wizard for the backend
  */
-class Wizard extends OpenidService implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class Wizard extends OpenidService {
 
        /**
         * OpenID of the user after authentication
@@ -54,15 +53,14 @@ class Wizard extends OpenidService implements \TYPO3\CMS\Core\Http\ControllerInt
         * Injects the request object for the current request or subrequest
         * Process the wizard and render HTML to response
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->processWizard();
                $content = $this->renderContent();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($content);
                return $response;
        }
@@ -71,7 +69,7 @@ class Wizard extends OpenidService implements \TYPO3\CMS\Core\Http\ControllerInt
         * Run the wizard and output HTML.
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function main() {
                GeneralUtility::logDeprecatedFunction();
@@ -82,7 +80,7 @@ class Wizard extends OpenidService implements \TYPO3\CMS\Core\Http\ControllerInt
        /**
         * Run the wizard
         */
-       protected function processWizard(){
+       protected function processWizard() {
                $p = GeneralUtility::_GP('P');
                if (isset($p['itemName'])) {
                        $this->parentFormItemName = $p['itemName'];
@@ -225,8 +223,10 @@ class Wizard extends OpenidService implements \TYPO3\CMS\Core\Http\ControllerInt
         * Render HTML and output it
         *
         * @return void
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
-       protected function renderHtml(){
+       protected function renderHtml() {
+               GeneralUtility::logDeprecatedFunction();
                header('HTTP/1.0 200 OK');
                echo $this->renderContent();
        }
index 36d79f3..ad2ee8f 100644 (file)
@@ -6,6 +6,6 @@ return [
        // Register wizard
        'wizard_openid' => [
                'path' => '/wizard/openid',
-               'controller' => \TYPO3\CMS\Openid\Wizard::class
+               'target' => \TYPO3\CMS\Openid\Wizard::class . '::mainAction'
        ]
 ];
index ea44225..b5cd0b8 100644 (file)
@@ -18,7 +18,6 @@ use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Lang\LanguageService;
 use TYPO3\CMS\Recordlist\Browser\ElementBrowser;
@@ -26,7 +25,7 @@ use TYPO3\CMS\Recordlist\Browser\ElementBrowser;
 /**
  * Script class for the Element Browser window.
  */
-class ElementBrowserController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ElementBrowserController {
 
        /**
         * The mode determines the main kind of output of the element browser.
@@ -77,12 +76,11 @@ class ElementBrowserController implements \TYPO3\CMS\Core\Http\ControllerInterfa
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response the prepared response object
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $response->getBody()->write($this->main());
                return $response;
        }
index 3ed134e..2f36799 100644 (file)
@@ -16,7 +16,6 @@ namespace TYPO3\CMS\Recordlist\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Backend\Template\DocumentTemplate;
 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Page\PageRenderer;
@@ -26,7 +25,7 @@ use TYPO3\CMS\Lang\LanguageService;
 /**
  * Script Class, putting the frameset together.
  */
-class ElementBrowserFramesetController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ElementBrowserFramesetController {
 
        /**
         * Internal, dynamic
@@ -51,14 +50,13 @@ class ElementBrowserFramesetController implements \TYPO3\CMS\Core\Http\Controlle
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response the prepared response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
@@ -109,7 +107,7 @@ class ElementBrowserFramesetController implements \TYPO3\CMS\Core\Http\Controlle
         * Outputs the page content.
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index ecc9bcf..25071c8 100644 (file)
@@ -6,6 +6,6 @@ return [
        // Register wizard element browser
        'wizard_element_browser' => [
                'path' => '/wizard/record/browse',
-               'controller' => \TYPO3\CMS\Recordlist\Controller\ElementBrowserController::class
+               'target' => \TYPO3\CMS\Recordlist\Controller\ElementBrowserController::class . '::mainAction'
        ]
 ];
\ No newline at end of file
index d584d19..02353e3 100644 (file)
@@ -16,13 +16,12 @@ namespace TYPO3\CMS\Rtehtmlarea\Controller;
 
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
  * Content parsing for htmlArea RTE
  */
-class ParseHtmlController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class ParseHtmlController {
 
        /**
         * @var string
@@ -76,14 +75,13 @@ class ParseHtmlController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main_parse_html() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->content .= $this->main_parse_html($this->modData['openKeys']);
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                $response = $response->withHeader('Content-Type', 'text/plain; charset=utf-8');
                return $response;
@@ -105,7 +103,7 @@ class ParseHtmlController implements \TYPO3\CMS\Core\Http\ControllerInterface {
         * Print content
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index 4f1188b..dcf2789 100644 (file)
@@ -17,7 +17,6 @@ namespace TYPO3\CMS\Rtehtmlarea\Controller;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use TYPO3\CMS\Core\Http\ControllerInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
index 8a157e9..0649381 100644 (file)
@@ -15,14 +15,12 @@ namespace TYPO3\CMS\Rtehtmlarea\Controller;
  */
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
-use TYPO3\CMS\Core\Http\Response;
-use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 /**
  * User defined content for htmlArea RTE
  */
-class UserElementsController implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class UserElementsController {
 
        /**
         * @var string
@@ -125,14 +123,12 @@ class UserElementsController implements \TYPO3\CMS\Core\Http\ControllerInterface
         * Injects the request object for the current request or subrequest
         * As this controller goes only through the main_user() method, it is rather simple for now
         *
-        * @param ServerRequestInterface $request
-        * @return ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response the prepared response object
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $content = $this->main_user($this->modData['openKeys']);
-
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($content);
                return $response;
        }
@@ -153,7 +149,7 @@ class UserElementsController implements \TYPO3\CMS\Core\Http\ControllerInterface
         * Print content
         *
         * @return void
-        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use processRequest() instead
+        * @deprecated since TYPO3 CMS 7, will be removed in TYPO3 CMS 8, use mainAction() instead
         */
        public function printContent() {
                GeneralUtility::logDeprecatedFunction();
index a407300..86c631f 100644 (file)
@@ -7,21 +7,21 @@ return [
        // Register RTE browse links wizard
        'rtehtmlarea_wizard_browse_links' => [
                'path' => '/rte/wizard/link',
-               'controller' => \TYPO3\CMS\Rtehtmlarea\Controller\BrowseLinksController::class
+               'target' => \TYPO3\CMS\Rtehtmlarea\Controller\BrowseLinksController::class . '::mainAction'
        ],
        // Register RTE select image wizard
        'rtehtmlarea_wizard_select_image' => [
                'path' => '/rte/wizard/image',
-               'controller' => \TYPO3\CMS\Rtehtmlarea\Controller\SelectImageController::class
+               'target' => \TYPO3\CMS\Rtehtmlarea\Controller\SelectImageController::class . '::mainAction'
        ],
        // Register RTE user elements wizard
        'rtehtmlarea_wizard_user_elements' => [
                'path' => '/rte/wizard/userelements',
-               'controller' => \TYPO3\CMS\Rtehtmlarea\Controller\UserElementsController::class
+               'target' => \TYPO3\CMS\Rtehtmlarea\Controller\UserElementsController::class . '::mainAction'
        ],
        // Register RTE parse html wizard
        'rtehtmlarea_wizard_parse_html' => [
                'path' => '/rte/wizard/parsehtml',
-               'controller' => \TYPO3\CMS\Rtehtmlarea\Controller\ParseHtmlController::class
+               'target' => \TYPO3\CMS\Rtehtmlarea\Controller\ParseHtmlController::class . '::mainAction'
        ],
 ];
index ba71e0d..3108715 100644 (file)
@@ -14,8 +14,8 @@ namespace TYPO3\CMS\Version\Controller;
  * The TYPO3 project - inspiring people to share!
  */
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use TYPO3\CMS\Core\Http\Response;
 use TYPO3\CMS\Core\Imaging\Icon;
 use TYPO3\CMS\Core\Imaging\IconFactory;
 use TYPO3\CMS\Core\Utility\ArrayUtility;
@@ -27,7 +27,7 @@ use TYPO3\CMS\Backend\Utility\IconUtility;
 /**
  * Versioning module, including workspace management
  */
-class VersionModuleController extends \TYPO3\CMS\Backend\Module\BaseScriptClass implements \TYPO3\CMS\Core\Http\ControllerInterface {
+class VersionModuleController extends \TYPO3\CMS\Backend\Module\BaseScriptClass {
 
        /**
         * Module configuration
@@ -531,17 +531,16 @@ class VersionModuleController extends \TYPO3\CMS\Backend\Module\BaseScriptClass
 
 
        /**
-        * Injects the request object for the current request and gathers all data
+        * Injects the request object for the current request and gathers all data.
         *
-        * @param ServerRequestInterface $request
-        * @return \Psr\Http\Message\ResponseInterface $response
+        * @param ServerRequestInterface $request the current request
+        * @param ResponseInterface $response the prepared response
+        * @return ResponseInterface the response with the content
         */
-       public function processRequest(ServerRequestInterface $request) {
+       public function mainAction(ServerRequestInterface $request, ResponseInterface $response) {
                $this->init();
                $this->main();
 
-               /** @var Response $response */
-               $response = GeneralUtility::makeInstance(Response::class);
                $response->getBody()->write($this->content);
                return $response;
        }
index 9ab3a7c..778176f 100644 (file)
@@ -7,6 +7,6 @@ return [
        // Register version_click_module entry point
        'web_txversionM1' => [
                'path' => '/record/versions/',
-               'controller' => \TYPO3\CMS\Version\Controller\VersionModuleController::class
+               'target' => \TYPO3\CMS\Version\Controller\VersionModuleController::class . '::mainAction'
        ]
 ];