Romm\Formz\Controller\FormController

Complexity

Total Complexity

19

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
B	processFormAction()	0	35	3
A	invokeMiddlewares()	0	18	3
A	manageRequestResult()	0	16	3
B	getRequestForms()	0	21	5
A	getRequestData()	0	12	2
A	injectFormzControllerContext()	0	4	1
A	injectHashService()	0	4	1
A	injectFormObjectFactory()	0	4	1

<?php
/*
 * 2017 Romain CANON <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 FormZ project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Controller;

use Romm\Formz\Core\Core;
use Romm\Formz\Form\FormInterface;
use Romm\Formz\Form\FormObject;
use Romm\Formz\Form\FormObjectFactory;
use Romm\Formz\Middleware\Request\Exception\RedirectException;
use Romm\Formz\Middleware\Request\Exception\StopPropagationException;
use Romm\Formz\Middleware\State\MiddlewareState;
use TYPO3\CMS\Extbase\Mvc\Controller\ActionController;
use TYPO3\CMS\Extbase\Mvc\Controller\Argument;
use TYPO3\CMS\Extbase\Security\Cryptography\HashService;

class FormController extends ActionController
{
    /**
     * @var FormObject[]
     */
    protected $formArguments = [];

    /**
     * @var FormzControllerContext
     */
    protected $formzControllerContext;

    /**
     * @var HashService
     */
    protected $hashService;

    /**
     * @var FormObjectFactory
     */
    protected $formObjectFactory;

    /**
     * Main action used to dispatch the request properly, depending on FormZ
     * configuration.
     *
     * The request is based on the previously called controller action, and is
     * used to list which forms are handled (every argument of the action method
     * that implements the interface `FormInterface`).
     *
     * Middlewares will be called for each form argument, and may modify the
     * request, which is then dispatched again with modified data.
     */
    public function processFormAction()
    {
        $tt = new \TYPO3\CMS\Core\TimeTracker\TimeTracker();
        $tt->start();

        try {
            $this->invokeMiddlewares();
            $this->manageRequestResult();
        } catch (StopPropagationException $exception) {
            if ($exception instanceof RedirectException) {
                $this->redirect(
                    $exception->getActionName(),
                    $exception->getControllerName(),
                    $exception->getExtensionName(),
                    $exception->getArguments(),
                    $exception->getPageUid(),
                    $exception->getDelay(),
                    $exception->getStatusCode()
                );
            }
        }

        $this->formzControllerContext->setDispatched(true);

        $request = $this->formzControllerContext->getRequest();

        $this->request->setControllerVendorName($this->formzControllerContext->getVendorName());

        $this->forward(
            $request->getControllerActionName(),
            $request->getControllerName(),
            $request->getControllerExtensionName(),
            $request->getArguments()
        );
    }

    /**
     * Will fetch every form argument for this request, and dispatch every
     * middleware that was registered in its TypoScript configuration.
     */
    protected function invokeMiddlewares()
    {
        foreach ($this->getRequestForms() as $formObject) {
            $formObject->reset();

            /*
             * If the configuration contains errors, then the middlewares
             * configuration may be corrupted as well, so the risk to dispatch
             * middlewares can not be taken.
             */
            if (false === $formObject->getConfigurationValidationResult()->hasErrors()) {
                /** @var MiddlewareState $middlewareFactory */
                $middlewareFactory = Core::instantiate(MiddlewareState::class, $formObject, $this->formzControllerContext);

                $middlewareFactory->run();
            }
        }
    }

    /**
     * Will check if the request result contains error; if errors are found, the
     * request is forwarded to the referring request, with the arguments of the
     * current request.
     */
    protected function manageRequestResult()
    {
        $request = $this->formzControllerContext->getRequest();
        $result = $request->getOriginalRequestMappingResults();
        $this->request->setOriginalRequestMappingResults($result);

        if ($result->hasErrors()) {
            $arguments = $request->getArguments();
            $referringRequest = $request->getReferringRequest();
            $this->formzControllerContext->setRequest($referringRequest);

It seems like $referringRequest defined by $request->getReferringRequest() on line 132 can be null; however, Romm\Formz\Controller\FormzControllerContext::setRequest() does not accept null, maybe add an additional type check?

            foreach ($arguments as $name => $value) {
                $referringRequest->setArgument($name, $value);
            }
        }
    }

    /**
     * Loops on the request arguments, and pick up each one that is a form
     * instance (it implements `FormInterface`).
     *
     * @return FormObject[]
     */
    protected function getRequestForms()
    {
        if (empty($this->formArguments)) {
            /** @var Argument $argument */
            foreach ($this->formzControllerContext->getArguments() as $argument) {
                $type = $argument->getDataType();

                if (class_exists($type)
                    && in_array(FormInterface::class, class_implements($type))
                ) {
                    $formClassName = $argument->getDataType();
                    $formName = $argument->getName();

                    $formObject = $this->formObjectFactory->getInstanceFromClassName($formClassName, $formName);
                    $this->formArguments[$formName] = $formObject;
                }
            }
        }

        return $this->formArguments;
    }

    /**
     * @todo
     *
     * @return array
     */
    protected function getRequestData()
    {
        $requestData = [];

        if ($this->request->hasArgument('formz')) {
            $requestData = $this->request->getArgument('formz');
            $requestData = $this->hashService->validateAndStripHmac($requestData);
            $requestData = unserialize(base64_decode($requestData));
        }

        return $requestData;
    }

    /**
     * @param FormzControllerContext $formzControllerContext
     */
    public function injectFormzControllerContext(FormzControllerContext $formzControllerContext)
    {
        $this->formzControllerContext = $formzControllerContext;
    }

    /**
     * @param HashService $hashService
     */
    public function injectHashService(HashService $hashService)
    {
        $this->hashService = $hashService;
    }

    /**
     * @param FormObjectFactory $formObjectFactory
     */
    public function injectFormObjectFactory(FormObjectFactory $formObjectFactory)
    {
        $this->formObjectFactory = $formObjectFactory;
    }
}