Yiisoft\Auth\Middleware\Authentication

Complexity

Total Complexity

8

Size/Duplication

Total Lines	55
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	withOptional()	0	5	1
A	process()	0	12	3
A	isOptional()	0	9	3

<?php

declare(strict_types=1);

namespace Yiisoft\Auth\Middleware;

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Auth\AuthenticationMethodInterface;
use Yiisoft\Auth\Handler\AuthenticationFailureHandler;
use Yiisoft\Strings\StringHelper;

/**
 * Authentication middleware tries to authenticate and identity using request data.
 * If identity is found, it is set to request attribute allowing further middleware to obtain and use it.
 * If identity is not found failure handler is called. By default it is {@see AuthenticationFailureHandler}.
 */
final class Authentication implements MiddlewareInterface
{
    private AuthenticationMethodInterface $authenticationMethod;

    /**
     * @var RequestHandlerInterface A handler that is called when there is a failure authenticating an identity.
     */
    private RequestHandlerInterface $failureHandler;

    private array $optional = [];

    public function __construct(
        AuthenticationMethodInterface $authenticationMethod,
        ResponseFactoryInterface $responseFactory,
        RequestHandlerInterface $authenticationFailureHandler = null
    ) {
        $this->authenticationMethod = $authenticationMethod;
        $this->failureHandler = $authenticationFailureHandler ?? new AuthenticationFailureHandler(
            $responseFactory
        );
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $identity = $this->authenticationMethod->authenticate($request);
        $request = $request->withAttribute(self::class, $identity);

        if ($identity === null && !$this->isOptional($request)) {
            return $this->authenticationMethod->challenge(
                $this->failureHandler->handle($request)
            );
        }

        return $handler->handle($request);
    }

    public function withOptional(array $optional): self
    {
        $new = clone $this;
        $new->optional = $optional;
        return $new;
    }

    /**
     * Checks, whether authentication is optional for the given action.
     */
    private function isOptional(ServerRequestInterface $request): bool
    {
        $path = $request->getUri()->getPath();
        foreach ($this->optional as $pattern) {
            if (StringHelper::matchWildcard($pattern, $path)) {
                return true;
            }
        }
        return false;
    }
}