Indragunawan\MiddlewareBundle\EventSubscriber\FilterSubscriber

Complexity

Total Complexity

16

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	onKernelController()	0	18	5
A	getSubscribedEvents()	0	5	1
A	onKernelResponse()	0	18	5
A	getClassAnnotations()	0	17	4

<?php

declare(strict_types=1);

/*
 * This file is part of the MiddlewareBundle
 *
 * (c) Indra Gunawan <hello@indra.my.id>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Indragunawan\MiddlewareBundle\EventSubscriber;

use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Util\ClassUtils;
use Indragunawan\MiddlewareBundle\Annotation\AfterFilter;
use Indragunawan\MiddlewareBundle\Annotation\BeforeFilter;
use Indragunawan\MiddlewareBundle\Middleware;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;

/**
 * @author Indra Gunawan <hello@indra.my.id>
 */
final class FilterSubscriber implements EventSubscriberInterface
{
    /**
     * @var Reader
     */
    private $reader;

    /**
     * @var Middleware
     */
    private $middleware;

    public function __construct(Reader $reader, Middleware $middleware)
    {
        $this->reader = $reader;
        $this->middleware = $middleware;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::CONTROLLER => ['onKernelController', 128],
            KernelEvents::RESPONSE => ['onKernelResponse', 128],
        ];
    }

    /**
     * @param FilterControllerEvent $event
     */
    public function onKernelController(FilterControllerEvent $event)
    {
        $controller = $event->getController();

        if (!\is_array($controller) && method_exists($controller, '__invoke')) {
            $controller = [$controller, '__invoke'];
        }

        if (!\is_array($controller)) {
            return;
        }

        $className = ClassUtils::getClass($controller[0]);
        $filters = $this->getClassAnnotations($className, $controller[1], BeforeFilter::class);
        $middlewares = $this->middleware->getMiddlewares('before_filter', $filters);

        foreach ($middlewares as $middleware) {
            $middleware->onBeforeFilter($event->getRequest(), [$className, $controller[1]], $event->getRequestType());
        }
    }

    /**
     * @param FilterResponseEvent $event
     */
    public function onKernelResponse(FilterResponseEvent $event)
    {
        // in request attributes '_controller' we trust
        $controller = $event->getRequest()->attributes->get('_controller');
        if (null === $controller) {
            return;
        }

        // $controller value should like 'App\Controller\HomepageController::index'
        $controller = explode('::', $controller);
        if (2 !== \count($controller) || !class_exists($controller[0])) {
            return;
        }

        $filters = $this->getClassAnnotations($controller[0], $controller[1], AfterFilter::class);
        $middlewares = $this->middleware->getMiddlewares('after_filter', $filters);
        foreach ($middlewares as $middleware) {
            $middleware->onAfterFilter($event->getRequest(), $event->getResponse(), $controller, $event->getRequestType());
        }
    }

    /**
     * @param string $className
     * @param string $method
     * @param string $annotationClass
     *
     * @return array
     */
    private function getClassAnnotations(string $className, string $method, string $annotationClass): array
    {
        $filters = [];
        $rejectedFilters = [];
        $classAnnotations = $this->reader->getClassAnnotations(new \ReflectionClass($className));

        foreach ($classAnnotations as $annotation) {
            if ($annotation instanceof $annotationClass) {
                if ($annotation->isSupportsMethod($method)) {
                    $filters = array_merge($filters, array_diff($annotation->getNames(), $rejectedFilters));
                } else {
                    $rejectedFilters = array_merge($rejectedFilters, $annotation->getNames());
                }
            }
        }

        return array_unique($filters);
    }
}