Romm\Formz\Controller\FormController

Complexity

Total Complexity

23

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
B	processFormAction()	0	31	4
A	formObjectErrorAction()	0	4	1
B	invokeMiddlewares()	0	25	3
A	manageRequestResult()	0	10	2
A	forwardToReferrer()	0	11	2
B	getRequestForms()	0	21	5
A	getRequestData()	0	12	2
A	redirectFromException()	0	12	1
A	injectState()	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\ForwardException;
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 ControllerState
     */
    protected $state;

    /**
     * @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();
        $originalRequest = clone $this->state->getRequest();

        try {
            $this->invokeMiddlewares();
            $this->manageRequestResult();
        } catch (StopPropagationException $exception) {
            if ($exception instanceof RedirectException) {
                $this->redirectFromException($exception);
            } elseif (false === $exception instanceof ForwardException) {
                $this->forwardToReferrer();
            }
        }

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

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

        $this->request->setControllerVendorName($this->state->getVendorName());
        $this->request->setOriginalRequest($originalRequest);

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

    /**
     * @param FormObject $formObject
     */
    public function formObjectErrorAction(FormObject $formObject)
    {
        $this->view->assign('formObject', $formObject);
    }

    /**
     * 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 ($formObject->getConfigurationValidationResult()->hasErrors()) {
                $this->forward(
                    'formObjectError',
                    null,
                    null,
                    ['formObject' => $formObject]
                );
            } else {
                /** @var MiddlewareState $middlewareState */
                $middlewareState = Core::instantiate(MiddlewareState::class, $formObject, $this->state);

                $middlewareState->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->state->getRequest();
        $result = $request->getOriginalRequestMappingResults();
        $this->request->setOriginalRequestMappingResults($result);

        if ($result->hasErrors()) {
            $this->forwardToReferrer();
        }
    }

    /**
     * Forwards the request to the referrer request. It will also fill the
     * arguments of the action with the one from the source request.
     */
    protected function forwardToReferrer()
    {
        $request = $this->state->getRequest();
        $arguments = $request->getArguments();
        $referringRequest = $request->getReferringRequest();
        $this->state->setRequest($referringRequest);

It seems like $referringRequest defined by $request->getReferringRequest() on line 155 can be null; however, Romm\Formz\Controller\ControllerState::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->state->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 RedirectException $redirectException
     */
    protected function redirectFromException(RedirectException $redirectException)
    {
        $this->redirect(
            $redirectException->getActionName(),
            $redirectException->getControllerName(),
            $redirectException->getExtensionName(),
            $redirectException->getArguments(),
            $redirectException->getPageUid(),
            $redirectException->getDelay(),
            $redirectException->getStatusCode()
        );
    }

    /**
     * @param ControllerState $state
     */
    public function injectState(ControllerState $state)
    {
        $this->state = $state;
    }

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

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