BrainExe\Core\Middleware\TokenAuthentication

Complexity

Total Complexity

10

Size/Duplication

Total Lines	78
Duplicated Lines	26.92 %

Coupling/Cohesion

Components	2
Dependencies	7

Test Coverage

Coverage

65.38%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	processRequest()	0	17	3
A	checkForRole()	9	9	3
A	loadUser()	12	12	3

<?php

namespace BrainExe\Core\Middleware;

use BrainExe\Core\Annotations\Middleware;
use BrainExe\Core\Authentication\AnonymusUserVO;
use BrainExe\Core\Authentication\Exception\UserNotFoundException;
use BrainExe\Core\Authentication\LoadUser;
use BrainExe\Core\Authentication\Token;
use BrainExe\Core\Authentication\UserVO;
use BrainExe\Core\Translation\TranslationTrait;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Route;

/**
 * @Middleware("Middleware.TokenAuthentication")
 */
class TokenAuthentication extends AbstractMiddleware
{
    use TranslationTrait;

    /**
     * @var LoadUser
     */
    private $loadUser;

    /**
     * @var Token
     */
    private $token;

    /**
     * @param LoadUser $loadUser
     * @param Token $token
     */
    public function __construct(LoadUser $loadUser, Token $token)
    {
        $this->loadUser = $loadUser;
        $this->token    = $token;
    }

    /**
     * {@inheritdoc}
     */
    public function processRequest(Request $request, Route $route)
    {
        $token = $request->get('accessToken');

        if (null === $token) {
            return null;
        }

        $userId = $this->token->hasUserForRole($token);
        if (null === $userId) {
            return null;
        }

        $user = $this->loadUser($userId);

        $request->attributes->set('user', $user);
    }

    /**
     * @todo check/implement

Comment refers to a TODO task

     * @param Route $route
     * @param UserVO $user
     * @throws MethodNotAllowedException
     */
    protected function checkForRole(Route $route, UserVO $user)
    {
        if ($route->hasDefault('_role')) {
            $role = $route->getDefault('_role');
            if (!in_array($role, $user->roles, true)) {
                throw new MethodNotAllowedException([], sprintf('Need role %s', $role));
            }
        }
    }

    /**
     * @param int $userId
     * @return AnonymusUserVO|UserVO
     */
    private function loadUser(int $userId) : UserVO
    {
        if ($userId > 0) {
            try {
                return $this->loadUser->loadUserById($userId);
            } catch (UserNotFoundException $e) {
                return new AnonymusUserVO();
            }
        } else {
            return new AnonymusUserVO();
        }
    }
}