Slick\WebStack\Domain\Security\Http\SecurityProfile\SecurityProfile

Complexity

Total Complexity

10

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	acl()	0	3	1
A	authenticationErrors()	0	3	1
A	processEntryPoint()	0	7	2
A	handleAuthenticationSuccess()	0	3	1
A	process()	0	12	4
A	__construct()	0	8	1

<?php

/**
 * This file is part of web-stack
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Slick\WebStack\Domain\Security\Http\SecurityProfile;

use Slick\WebStack\Domain\Security\Authentication\Token\TokenStorageInterface;
use Slick\WebStack\Domain\Security\Http\AuthenticationEntryPointInterface;
use Slick\WebStack\Domain\Security\Http\AuthenticatorManagerInterface;
use Slick\WebStack\Domain\Security\Http\SecurityProfileInterface;
use Slick\WebStack\Domain\Security\UserInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Slick\Http\Message\Response;

/**
 * SecurityProfile
 *
 * @package Slick\WebStack\Domain\Security\Http\SecurityProfile
 */
class SecurityProfile implements SecurityProfileInterface
{
    use SecurityProfileTrait;

    public const REQUEST_TOKEN_KEY = '_security_token';

    /**
     * Creates a SecurityProfile
     *
     * @param string $matchExp
     * @param AuthenticatorManagerInterface $authenticatorManager
     * @param TokenStorageInterface<UserInterface> $tokenStorage
     * @param AuthenticationEntryPointInterface|null $entryPoint
     * @param array<string> $acl
     */
    public function __construct(
        string $matchExp,
        protected readonly AuthenticatorManagerInterface $authenticatorManager,
        protected readonly TokenStorageInterface $tokenStorage,
        private readonly ?AuthenticationEntryPointInterface $entryPoint = null,
        private readonly array $acl = []
    ) {
        $this->matchExp = $matchExp;
    }

    /**
     * Processes the given server request by authenticating it or delegating to the entry point.
     *
     * @param ServerRequestInterface $request The server request to process.
     * @return ResponseInterface|null Returns the authenticated response or null if authentication is not supported.
     */
    public function process(ServerRequestInterface $request): ?ResponseInterface
    {
        $supports = $this->authenticatorManager->supports($request);
        if (!$supports) {

The expression $supports of type boolean|null is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

              return null;
        }

        $response =  $this->authenticatorManager->authenticateRequest($request);
        if (is_null($response) || $response->getStatusCode() < 400) {
            $this->handleAuthenticationSuccess($request);
        }
        return $response;
    }

    /**
     * Processes the entry point for the given server request.
     *
     * If an entry point is defined, it will start the authentication process
     * using the provided server request. Otherwise, it returns a response with
     * a status code of 401 (Unauthorized).
     *
     * @param ServerRequestInterface $request The server request to process the entry point.
     * @return null|ResponseInterface Returns the response of the entry point or a response with
     *                           a status code of 401 (Unauthorized).
     */
    public function processEntryPoint(ServerRequestInterface $request): ?ResponseInterface
    {
        if ($this->entryPoint) {
            return $this->entryPoint->start($request);
        }

        return new Response(401, 'Unauthorized');
    }

    /**
     * Handles successful authentication by adding the token attribute to the request.
     *
     * @param ServerRequestInterface &$request The incoming request object.
     *
     * @return void
     */
    protected function handleAuthenticationSuccess(ServerRequestInterface &$request): void
    {
        $request = $request->withAttribute(self::REQUEST_TOKEN_KEY, $this->tokenStorage->getToken());
    }

    /**
     * @inheritDoc
     */
    
    public function authenticationErrors(): array
    {
        return $this->authenticatorManager->authenticationErrors();
    }

    /**
     * @inheritDoc
     */
    public function acl(): array
    {
        return $this->acl;
    }
}