Equip\Auth\AuthHandler

Complexity

Total Complexity

8

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	handleToken()	0	4	1
A	shouldFilter()	0	7	2
A	__invoke()	0	19	4

<?php

namespace Equip\Auth;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Equip\Auth\AdapterInterface;
use Equip\Auth\Credentials\ExtractorInterface as CredentialsExtractor;
use Equip\Auth\Token\ExtractorInterface as TokenExtractor;
use Equip\Auth\Exception\UnauthorizedException;

class AuthHandler
{
    const TOKEN_ATTRIBUTE = 'spark/auth:token';

    /**
     * @var \Equip\Auth\Token\ExtractorInterface
     */
    protected $token;

    /**
     * @var \Equip\Auth\Credentials\ExtractorInterface
     */
    protected $credentials;

    /**
     * @var AdapterInterface
     */
    protected $adapter;

    /**
     * @var RequestFilterInterface
     */
    protected $filter;

    /**
     * @param \Equip\Auth\Token\ExtractorInterface $token
     * @param \Equip\Auth\Credentials\ExtractorInterface $credentials
     * @param AdapterInterface $adapter
     * @param RequestFilterInterface $filter
     */
    public function __construct(
        TokenExtractor $token,
        CredentialsExtractor $credentials,
        AdapterInterface $adapter,
        RequestFilterInterface $filter = null
    ) {
        $this->token = $token;

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

        $this->credentials = $credentials;
        $this->adapter = $adapter;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $this->filter = $filter;

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

    }

    /**
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     * @param callable $next
     * @return array
     */
    public function __invoke(
        ServerRequestInterface $request,
        ResponseInterface $response,
        callable $next
    ) {
        if ($this->shouldFilter($request)) {
            if ($token = $this->token->getToken($request)) {
                $authToken = $this->adapter->validateToken($token);
            } elseif ($credentials = $this->credentials->getCredentials($request)) {
                $authToken = $this->adapter->validateCredentials($credentials);
            } else {
                throw new UnauthorizedException;
            }

            $request = $this->handleToken($request, $authToken);
        }

        return $next($request, $response);
    }

    /**
     * Handle the Token and put it in the request
     *
     * @param ServerRequestInterface $request
     * @param Token $token
     * @return ServerRequestInterface
     */
    protected function handleToken(ServerRequestInterface $request, Token $token)
    {
        return $request->withAttribute(static::TOKEN_ATTRIBUTE, $token);
    }

    /**
     * @param ServerRequestInterface $request
     * @return boolean
     */
    protected function shouldFilter(ServerRequestInterface $request)
    {
        if (!$this->filter) {
            return true;
        }
        return call_user_func($this->filter, $request);
    }
}