Romm\Formz\Middleware\State\MiddlewareState

Complexity

Total Complexity

22

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	run()	0	10	1
A	dispatchBeforeSignal()	0	10	3
A	dispatchAfterSignal()	0	10	3
B	getSignalSortedMiddlewares()	0	23	5
A	sortMiddlewaresListByPriority()	0	17	3
A	getFormObject()	0	4	1
A	getRequest()	0	4	1
A	getRequestArguments()	0	4	1
A	getMiddlewaresBoundToSignal()	0	8	2

<?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\Middleware\State;

use Romm\Formz\Controller\FormzControllerContext;
use Romm\Formz\Form\FormObject;
use Romm\Formz\Middleware\Items\Begin\BeginMiddleware;
use Romm\Formz\Middleware\Items\End\EndMiddleware;
use Romm\Formz\Middleware\MiddlewareInterface;
use Romm\Formz\Middleware\Signal\After;
use Romm\Formz\Middleware\Signal\Before;
use Romm\Formz\Middleware\Signal\SendsMiddlewareSignal;
use TYPO3\CMS\Extbase\Mvc\Controller\Arguments;
use TYPO3\CMS\Extbase\Mvc\Web\Request;

/**
 * @todo: loop on middlewares and detect which ones are using signals that wont
 * be processed. This should probably be a validator put on:
 *      \Romm\Formz\Configuration\Form\Form::$middlewares
 */
class MiddlewareState
{
    /**
     * @var MiddlewareInterface[]
     */
    protected $list = [];

    /**
     * @var FormObject
     */
    protected $formObject;

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

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

    /**
     * @see getSignalSortedMiddlewares()
     *
     * @var array
     */
    protected $signalSortedMiddlewares = [];

    /**
     * @param FormObject             $formObject
     * @param FormzControllerContext $formzControllerContext
     */
    public function __construct(FormObject $formObject, FormzControllerContext $formzControllerContext)
    {
        $this->formObject = $formObject;
        $this->request = $formzControllerContext->getRequest();
        $this->requestArguments = $formzControllerContext->getArguments();

        foreach ($this->formObject->getConfiguration()->getMiddlewares() as $middleware) {
            $middleware->bindMiddlewareState($this);
            $this->list[] = $middleware;
        }
    }

    /**
     * Will run and process trough every middleware registered for the current
     * form object.
     */
    public function run()
    {
        $beginMiddleware = new BeginMiddleware;
        $beginMiddleware->bindMiddlewareState($this);
        $beginMiddleware->execute();

        $endMiddleware = new EndMiddleware;
        $endMiddleware->bindMiddlewareState($this);
        $endMiddleware->execute();
    }

    /**
     * Will dispatch the before-signal from a given source to all middlewares
     * bound to the signal.
     *
     * @param SendsMiddlewareSignal $source
     */
    public function dispatchBeforeSignal(SendsMiddlewareSignal $source)
    {
        $signalName = $source->getSignalName();

        foreach ($this->getMiddlewaresBoundToSignal($signalName) as $middleware) {
            if ($middleware instanceof Before) {
                $middleware->before();
            }
        }
    }

    /**
     * Will dispatch the after-signal from a given source to all middlewares
     * bound to the signal.
     *
     * @param SendsMiddlewareSignal $source
     */
    public function dispatchAfterSignal(SendsMiddlewareSignal $source)
    {
        $signalName = $source->getSignalName();

        foreach ($this->getMiddlewaresBoundToSignal($signalName) as $middleware) {
            if ($middleware instanceof After) {
                $middleware->after();
            }
        }
    }

    /**
     * Returns the sorted list of middlewares bound to the given signal name.
     *
     * @param string $signalName
     * @return array
     */
    protected function getMiddlewaresBoundToSignal($signalName)
    {
        $signalSortedMiddlewares = $this->getSignalSortedMiddlewares();

        return (isset($signalSortedMiddlewares[$signalName]))
            ? $signalSortedMiddlewares[$signalName]
            : [];
    }

    /**
     * Returns a sorted list of the registered middlewares: the first level is
     * the signal used by the group, and the second level is the group of
     * middlewares, sorted by descendant priority of each middleware.
     *
     * @return array
     */
    protected function getSignalSortedMiddlewares()
    {
        if (empty($this->signalSortedMiddlewares)) {
            $this->signalSortedMiddlewares = [];
            $middlewareList = [];

            foreach ($this->list as $middleware) {
                $signal = $middleware->getBoundSignalName();

                if (false === isset($middlewareList[$signal])) {
                    $middlewareList[$signal] = [];
                }

                $middlewareList[$signal][] = $middleware;
            }

            foreach ($middlewareList as $key => $list) {
                $this->signalSortedMiddlewares[$key] = $this->sortMiddlewaresListByPriority($list);
            }
        }

        return $this->signalSortedMiddlewares;
    }

    /**
     * Will sort and return a middlewares list based on the priority of each
     * middleware. The middlewares with the highest priority will be placed at
     * the top of the list.
     *
     * @param array $list
     * @return array
     */
    private function sortMiddlewaresListByPriority(array $list)
    {
        usort($list, function (MiddlewareInterface $a, MiddlewareInterface $b) {
            $priorityA = (int)$a->getPriority();
            $priorityB = (int)$b->getPriority();

            if ($priorityA === $priorityB) {
                return 0;
            }

            return $priorityA < $priorityB
                ? 1
                : -1;
        });

        return $list;
    }

    /**
     * @return FormObject
     */
    public function getFormObject()
    {
        return $this->formObject;
    }

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

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