LM\AuthAbstractor\Controller\AuthenticationKernel

Complexity

Total Complexity

7

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getAuthenticationProcessFactory()	0	3	1
A	getContainer()	0	3	1
A	processHttpRequest()	0	29	3
A	__construct()	0	66	2

<?php

declare(strict_types=1);

namespace LM\AuthAbstractor\Controller;

use DI\Container;
use DI\ContainerBuilder;
use LM\AuthAbstractor\Configuration\IApplicationConfiguration;
use LM\AuthAbstractor\Factory\AuthenticationProcessFactory;
use LM\AuthAbstractor\Model\IAuthenticationKernel;
use LM\AuthAbstractor\Model\AuthenticationProcess;
use LM\AuthAbstractor\Model\IAuthentifierResponse;
use LM\AuthAbstractor\Model\IAuthenticationCallback;
use LM\AuthAbstractor\Exception\FinishedProcessException;
use Psr\Http\Message\ServerRequestInterface;
use Symfony\Bridge\Twig\Extension\FormExtension;
use Symfony\Bridge\Twig\Extension\TranslationExtension;
use Symfony\Bridge\Twig\Form\TwigRendererEngine;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\Forms;
use Symfony\Component\Form\Extension\Csrf\CsrfExtension;
use Symfony\Component\Security\Csrf\TokenGenerator\UriSafeTokenGenerator;
use Symfony\Component\Security\Csrf\CsrfTokenManager;
use Symfony\Component\Form\FormRenderer;
use Symfony\Component\Translation\Translator;
use Symfony\Component\Translation\Loader\XliffFileLoader;
use Symfony\Component\Form\Extension\HttpFoundation\HttpFoundationExtension;
use Symfony\Component\Form\Extension\Validator\ValidatorExtension;
use Twig_Environment;
use Twig_FactoryRuntimeLoader;
use Twig_Function;
use Psr\Container\ContainerInterface;
use Twig_Loader_Filesystem;
use Symfony\Component\Validator\Validation;

/**
 * This is the main entry point of the library. It acts as an HTTP middleware.
 *
 * It is initialised with the configuration of the application. It can then
 * be passed an HTTP request among other things and it will return an HTTP
 * response (among other things).
 *
 * @todo Make it implement PSR-15.
 */
class AuthenticationKernel implements IAuthenticationKernel
{
    /** @var IApplicationConfiguration */
    private $appConfig;

    /** @var ContainerInterface */
    private $container;

    /**
     * @param IApplicationConfiguration $appConfig The configuration of the
     * application. It needs to be an implementation of
     * IApplicationConfiguration. You are not obliged to define your own
     * implementation, and can just use the Configuration class for convenience.
     * @todo Ensure container keeps and reuses objects.
     * @todo Form validation doesn't work. Delete?
     * @todo Make it possible to specify an anonymous challenge.
     */
    public function __construct(IApplicationConfiguration $appConfig)
    {
        $this->appConfig = $appConfig;

        $twigPaths = [
            $appConfig->getLibdir().'/templates',
            $appConfig->getComposerDir().'/symfony/twig-bridge/Resources/views/Form',
        ];

        if (null !== $appConfig->getCustomTwigDir()) {
            $twigPaths[] = $appConfig->getCustomTwigDir();
        }

        $loader = new Twig_Loader_Filesystem($twigPaths);
        $twig = new Twig_Environment($loader, [
            "cache" => false,
        ]);
        $assetFunction = new Twig_Function("asset", [
            $appConfig,
            "getAssetUri",
        ]);
        $twig->addFunction($assetFunction);
        $translator = new Translator('en');
        $translator->addLoader('xlf', new XliffFileLoader());
        // $translator->addResource(
        //     'xlf',
        //     __DIR__.'/path/to/translations/messages.en.xlf',
        //     'en'
        // );
        $twig->addExtension(new TranslationExtension($translator));

        $csrfGenerator = new UriSafeTokenGenerator();
        $csrfStorage = $this->appConfig->getTokenStorage();
        $csrfManager = new CsrfTokenManager($csrfGenerator, $csrfStorage);

        $defaultFormTheme = "form_div_layout.html.twig";

        $formEngine = new TwigRendererEngine([$defaultFormTheme], $twig);
        $twig->addRuntimeLoader(new Twig_FactoryRuntimeLoader([
            FormRenderer::class => function () use ($formEngine, $csrfManager) {
                return new FormRenderer($formEngine, $csrfManager);
            },
        ]));
        $twig->addExtension(new FormExtension());
        $validator = Validation::createValidator();
        $formFactory = Forms::createFormFactoryBuilder()
            ->addExtension(new CsrfExtension($csrfManager))
            ->addExtension(new HttpFoundationExtension())
            ->addExtension(new HttpFoundationExtension())
            ->addExtension(new ValidatorExtension($validator))
            ->getFormFactory()
        ;

        $containerBuilder = new ContainerBuilder();
        $containerBuilder->addDefinitions([
            IApplicationConfiguration::class => function () use ($appConfig) {
                return $appConfig;
            },
            Twig_Environment::class => function () use ($twig) {
                return $twig;
            },
            FormFactoryInterface::class => function () use ($formFactory) {
                return $formFactory;
            },
        ]);
        $this->container = $containerBuilder->build();
    }

    /**
     * Used for unit testing only.
     *
     * @internal
     * @return ContainerInterface The container of auth-abstractor.
     */
    public function getContainer(): ContainerInterface
    {
        return $this->container;
    }

    /**
     * Returns the authentication process factory, which can be used to create
     * authentication processes. This is the recommended way to create
     * authentication processes, as it aims to be more backwards-compatible and
     * is simply easier to use.
     *
     * @return AuthenticationProcessFactory An authenticationProcessFactory
     */
    public function getAuthenticationProcessFactory(): AuthenticationProcessFactory
    {
        return $this->container->get(AuthenticationProcessFactory::class);
    }

    /**
     * @todo Should check type before instantiating authentifier.
     * @todo Move somewhere else?
     */
    public function processHttpRequest(
        ServerRequestInterface $httpRequest,
        AuthenticationProcess $process,
        IAuthenticationCallback $callback
    ): IAuthentifierResponse {
        if ($process->isFinished()) {
            throw new FinishedProcessException();
        }

        $processHandler = $this
            ->container
            ->get(AuthenticationProcessHandler::class)
        ;

        $authentifierResponse = null;
        $lastProcess = $process;
        $httpResponse = null;
        while (null === $httpResponse) {
            $authentifierResponse = $processHandler->handleAuthenticationProcess(
                $httpRequest,
                $lastProcess,
                $callback
            );
            $lastProcess = $authentifierResponse->getAuthenticationProcess();
            $httpRequest = null;
            $httpResponse = $authentifierResponse->getHttpResponse();
        }

        return $authentifierResponse;
    }
}