OAuth2Framework\Bundle\Server\Annotation\AnnotationDriver

Complexity

Total Complexity

13

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	addChecker()	0	6	1
A	getCheckers()	0	4	1
C	onKernelController()	0	32	7
A	createAuthenticationException()	0	14	1
A	createAccessDeniedException()	0	11	1
A	updateFilterControllerEvent()	0	9	1

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace OAuth2Framework\Bundle\Server\Annotation;

use Doctrine\Common\Annotations\Reader;
use OAuth2Framework\Bundle\Server\Annotation\Checker\CheckerInterface;
use OAuth2Framework\Bundle\Server\Security\Authentication\Token\OAuth2Token;
use OAuth2Framework\Component\Server\Response\OAuth2ResponseFactoryManager;
use OAuth2Framework\Component\Server\Response\OAuth2ResponseInterface;
use OAuth2Framework\Component\Server\TokenType\TokenTypeManager;
use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;

final class AnnotationDriver
{
    /**
     * @var Reader
     */
    private $reader;

    /**
     * @var TokenStorageInterface
     */
    private $tokenStorage;

    /**
     * @var CheckerInterface[]
     */
    private $checkers = [];

    /**
     * @var TokenTypeManager
     */
    private $tokenTypeManager;

    /**
     * @var OAuth2ResponseFactoryManager
     */
    private $oauth2ResponseFactoryManager;

    /**
     * AnnotationDriver constructor.
     *
     * @param Reader                       $reader
     * @param TokenStorageInterface        $tokenStorage
     * @param TokenTypeManager             $tokenTypeManager
     * @param OAuth2ResponseFactoryManager $oauth2ResponseFactoryManager
     */
    public function __construct(Reader $reader, TokenStorageInterface $tokenStorage, TokenTypeManager $tokenTypeManager, OAuth2ResponseFactoryManager $oauth2ResponseFactoryManager)
    {
        $this->reader = $reader;
        $this->tokenStorage = $tokenStorage;
        $this->tokenTypeManager = $tokenTypeManager;
        $this->oauth2ResponseFactoryManager = $oauth2ResponseFactoryManager;
    }

    /**
     * @param CheckerInterface $checker
     *
     * @return AnnotationDriver
     */
    public function addChecker(CheckerInterface $checker): self
    {
        $this->checkers[] = $checker;

        return $this;
    }

    /**
     * @return CheckerInterface[]
     */
    public function getCheckers(): array
    {
        return $this->checkers;
    }

    public function onKernelController(FilterControllerEvent $event)
    {
        if (!is_array($controller = $event->getController())) {
            return;
        }

        $object = new \ReflectionObject($controller[0]);
        $method = $object->getMethod($controller[1]);
        $classConfigurations = $this->reader->getClassAnnotations($object);
        $methodConfigurations = $this->reader->getMethodAnnotations($method);

        foreach (array_merge($classConfigurations, $methodConfigurations) as $configuration) {
            if ($configuration instanceof OAuth2) {
                $token = $this->tokenStorage->getToken();

                if (!$token instanceof OAuth2Token) {
                    $this->createAuthenticationException($event, 'OAuth2 authentication required');

                    return;
                }

                foreach ($this->getCheckers() as $checker) {
                    $message = $checker->check($token, $configuration);
                    if (null !== $message) {
                        $this->createAccessDeniedException($event, $message);

                        return;
                    }
                }
            }
        }
    }

    /**
     * @param FilterControllerEvent $event
     * @param string                $message
     */
    private function createAuthenticationException(FilterControllerEvent &$event, $message)
    {
        $schemes = $this->tokenTypeManager->getSchemes();
        $response = $this->oauth2ResponseFactoryManager->getResponse(
            401,
            [
                'error' => OAuth2ResponseFactoryManager::ERROR_ACCESS_DENIED,
                'error_description' => $message,
                'schemes' => $schemes,
            ]
        );

        $this->updateFilterControllerEvent($event, $response);
    }

    /**
     * @param FilterControllerEvent $event
     * @param string                $message
     */
    private function createAccessDeniedException(FilterControllerEvent &$event, $message)
    {
        $response = $this->oauth2ResponseFactoryManager->getResponse(
            403,
            [
                'error' => OAuth2ResponseFactoryManager::ERROR_ACCESS_DENIED,
                'error_description' => $message,
            ]
        );
        $this->updateFilterControllerEvent($event, $response);
    }

    /**
     * @param FilterControllerEvent   $event
     * @param OAuth2ResponseInterface $response
     */
    private function updateFilterControllerEvent(FilterControllerEvent &$event, OAuth2ResponseInterface $response)
    {
        $event->setController(function () use ($response) {
            $factory = new HttpFoundationFactory();
            $response = $factory->createResponse($response->getResponse());

Consider using a different name than the imported variable $response, or did you forget to import by reference?

            return $response;
        });
    }
}