Romm\Formz\Controller\ControllerState

Complexity

Total Complexity

14

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	dispatch()	0	25	2
A	checkFormObjectsErrors()	0	11	3
B	getRequestForms()	0	21	5
A	getRequest()	0	4	1
A	getArguments()	0	4	1
A	getSettings()	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\Form\FormInterface;
use Romm\Formz\Form\FormObject;
use Romm\Formz\Form\FormObjectFactory;
use Romm\Formz\Service\Traits\ExtendedSelfInstantiateTrait;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Extbase\Mvc\Controller\Argument;
use TYPO3\CMS\Extbase\Mvc\Controller\Arguments;
use TYPO3\CMS\Extbase\Mvc\Exception\StopActionException;
use TYPO3\CMS\Extbase\Mvc\Request as MvcRequest;
use TYPO3\CMS\Extbase\Mvc\Web\Request;

class ControllerState implements SingletonInterface
{
    use ExtendedSelfInstantiateTrait;

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

    /**
     * @var FormObject[]
     */
    protected $formArguments = [];

    /**
     * @var bool
     */
    protected $dispatched = false;

    /**
     * @var Request
     */
    protected $request;

    /**
     * @var Request
     */
    protected $originalRequest;

    /**
     * @var Arguments
     */
    protected $arguments;

    /**
     * @var array
     */
    protected $settings = [];

    /**
     * @todo
     *
     * @param MvcRequest $request
     * @param Arguments  $arguments
     * @param array      $settings
     * @throws StopActionException
     */
    public function dispatch(MvcRequest $request, Arguments $arguments, array $settings)
    {
        if (false === $this->dispatched) {
            $this->dispatched = true;

            /** @var Request $request */
            $this->request = clone $request;
            $this->originalRequest = clone $request;
            $this->arguments = $arguments;
            $this->settings = $settings;

            $request->setDispatched(false);
            $request->setControllerVendorName('Romm');
            $request->setControllerName('Form');
            $request->setControllerExtensionName('Formz');
            $request->setControllerActionName('processForm');
            $request->setArguments([
                'originalRequest' => $this->originalRequest
            ]);

            $this->checkFormObjectsErrors($request);

            throw new StopActionException;
        }
    }

    /**
     * Will check if the form objects found in the request arguments contain
     * configuration errors. If they do, we dispatch the request to the error
     * view, where all errors will be explained properly to the user.
     *
     * @param MvcRequest $request
     */
    protected function checkFormObjectsErrors(MvcRequest $request)
    {
        foreach ($this->getRequestForms() as $formObject) {
            if ($formObject->getConfigurationValidationResult()->hasErrors()) {
                $request->setControllerActionName('formObjectError');
                $request->setArguments(['formObject' => $formObject]);

                break;
            }
        }
    }

    /**
     * Loops on the request arguments, and pick up each one that is a form
     * instance (it implements `FormInterface`).
     *
     * @return FormObject[]
     */
    public function getRequestForms()
    {
        if (empty($this->formArguments)) {
            /** @var Argument $argument */
            foreach ($this->arguments 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;
    }

    /**
     * @return Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * @return Arguments
     */
    public function getArguments()
    {
        return $this->arguments;
    }

    /**
     * @return array
     */
    public function getSettings()
    {
        return $this->settings;
    }

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