BrainExe\Core\Middleware\Authentication

Complexity

Total Complexity

13

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

84.85%

Importance

Changes	8
Bugs	0	Features	2

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	processRequest()	0	26	4
A	checkForRole()	0	9	3
A	loadUser()	0	12	3
A	handleNotAuthenticatedRequest()	0	7	2

<?php

namespace BrainExe\Core\Middleware;

use BrainExe\Annotations\Annotations\Inject;
use BrainExe\Core\Annotations\Middleware;
use BrainExe\Core\Application\UserException;
use BrainExe\Core\Authentication\AnonymusUserVO;
use BrainExe\Core\Authentication\Exception\UserNotFoundException;
use BrainExe\Core\Authentication\LoadUser;
use BrainExe\Core\Authentication\UserVO;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Route;

/**
 * @Middleware("Middleware.Authentication")
 */
class Authentication extends AbstractMiddleware
{
    /**
     * @var LoadUser
     */
    private $loadUser;

    /**
     * @Inject({
     *  "@Core.Authentication.LoadUser",
     * })
     * @param LoadUser $loadUser
     */
    public function __construct(LoadUser $loadUser)
    {
        $this->loadUser      = $loadUser;
    }

    /**
     * {@inheritdoc}
     */
    public function processRequest(Request $request, Route $route)
    {
        if ($request->attributes->has('user')) {
            return null;
        }

        $session = $request->getSession();
        $userId  = (int)$session->get('user_id');

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

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

        $this->checkForRole($route, $user);

        if ($route->hasDefault('_guest')) {
            return null;
        }

        if (empty($userId)) {
            return $this->handleNotAuthenticatedRequest($request);
        }

        return null;
    }

    /**
     * @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)) {
                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();
        }
    }

    /**
     * @param Request $request
     * @return RedirectResponse
     * @throws UserException
     */
    private function handleNotAuthenticatedRequest(Request $request)
    {
        if ($request->isXmlHttpRequest()) {
            throw new UserException(gettext('Not logged in'));
        }
        return new RedirectResponse('#/login');
    }
}