9.5/_plugin_enhancer_8php_source.html

<?php

declare(strict_types = 1);


namespace ‪TYPO3\CMS\Core\Routing\Enhancer;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Core\Routing\Aspect\StaticMappableAspectInterface;

use ‪TYPO3\CMS\Core\Routing\PageArguments;

use ‪TYPO3\CMS\Core\Routing\Route;

use ‪TYPO3\CMS\Core\Routing\RouteCollection;

use ‪TYPO3\CMS\Core\Utility\ArrayUtility;


class ‪PluginEnhancer extends ‪AbstractEnhancer implements ‪RoutingEnhancerInterface, ‪InflatableEnhancerInterface, ‪ResultingInterface

{

    protected ‪$configuration;


    protected ‪$namespace;


    public function ‪__construct(array ‪$configuration)

    {

        $this->configuration = ‪$configuration;

        $this->namespace = $this->configuration['namespace'] ?? '';

    }


    public function ‪buildResult(‪Route $route, array $results, array $remainingQueryParameters = []): ‪PageArguments

    {

        ‪$variableProcessor = $this->‪getVariableProcessor();

        // determine those parameters that have been processed

        $parameters = array_intersect_key(

            $results,

            array_flip($route->compile()->getPathVariables())

        );

        // strip of those that where not processed (internals like _route, etc.)

        $internals = array_diff_key($results, $parameters);

        $matchedVariableNames = array_keys($parameters);


        $staticMappers = $route->‪filterAspects([StaticMappableAspectInterface::class], $matchedVariableNames);

        $dynamicCandidates = array_diff_key($parameters, $staticMappers);


        // all route arguments

        $routeArguments = $this->‪inflateParameters($parameters, $internals);

        // dynamic arguments, that don't have a static mapper

        $dynamicArguments = ‪$variableProcessor

            ->‪inflateNamespaceParameters($dynamicCandidates, $this->namespace);

        // route arguments, that don't appear in dynamic arguments

        $staticArguments = ‪ArrayUtility::arrayDiffAssocRecursive($routeArguments, $dynamicArguments);


        $page = $route->getOption('_page');

        $pageId = (int)($page['l10n_parent'] > 0 ? $page['l10n_parent'] : $page['uid']);

        // See PageSlugCandidateProvider where this is added.

        if ($page['MPvar'] ?? '') {

            $routeArguments['MP'] = $page['MPvar'];

        }

        $type = $this->‪resolveType($route, $remainingQueryParameters);

        return new ‪PageArguments($pageId, $type, $routeArguments, $staticArguments, $remainingQueryParameters);

    }


    public function ‪enhanceForMatching(RouteCollection $collection): void

    {

        $defaultPageRoute = $collection->get('default');

        $variant = $this->‪getVariant($defaultPageRoute, $this->configuration);

        $collection->add('enhancer_' . $this->namespace . spl_object_hash($variant), $variant);

    }


    protected function ‪getVariant(Route $defaultPageRoute, array ‪$configuration): Route

    {

        $arguments = ‪$configuration['_arguments'] ?? [];

        unset(‪$configuration['_arguments']);


        ‪$variableProcessor = $this->‪getVariableProcessor();

        $routePath = $this->‪modifyRoutePath($configuration['routePath']);

        $routePath = ‪$variableProcessor->‪deflateRoutePath($routePath, $this->namespace, $arguments);

        $variant = clone $defaultPageRoute;

        $variant->setPath(rtrim($variant->getPath(), '/') . '/' . ltrim($routePath, '/'));

        $variant->addOptions(['_enhancer' => $this, '_arguments' => $arguments]);

        $defaults = ‪$variableProcessor->‪deflateKeys($this->configuration['defaults'] ?? [], $this->namespace, $arguments);

        // only keep `defaults` that are actually used in `routePath`

        $variant->setDefaults($this->‪filterValuesByPathVariables($variant, $defaults));

        $this->‪applyRouteAspects($variant, $this->aspects ?? [], $this->namespace);

        $this->‪applyRequirements($variant, $this->configuration['requirements'] ?? [], $this->namespace);

        return $variant;

    }


    public function ‪enhanceForGeneration(RouteCollection $collection, array $parameters): void

    {

        // No parameter for this namespace given, so this route does not fit the requirements

        if (!is_array($parameters[$this->namespace])) {

            return;

        }

        $defaultPageRoute = $collection->get('default');

        $variant = $this->‪getVariant($defaultPageRoute, $this->configuration);

        $compiledRoute = $variant->compile();

        // contains all given parameters, even if not used as variables in route

        $deflatedParameters = $this->‪deflateParameters($variant, $parameters);

        $variables = array_flip($compiledRoute->getPathVariables());

        $mergedParams = array_replace($variant->getDefaults(), $deflatedParameters);

        // all params must be given, otherwise we exclude this variant

        if ($variables === [] || array_diff_key($variables, $mergedParams) !== []) {

            return;

        }

        $variant->addOptions(['deflatedParameters' => $deflatedParameters]);

        $collection->add('enhancer_' . $this->namespace . spl_object_hash($variant), $variant);

    }


    protected function ‪getNamespacedRequirements(): array

    {

        $requirements = [];

        foreach ($this->configuration['requirements'] ?? [] as $name => $value) {

            $requirements[$this->namespace . '_' . $name] = $value;

        }

        return $requirements;

    }


    protected function ‪deflateParameters(Route $route, array $parameters): array

    {

        return $this->‪getVariableProcessor()->‪deflateNamespaceParameters(

            $parameters,

            $this->namespace,

            $route->getArguments()

        );

    }


    public function ‪inflateParameters(array $parameters, array $internals = []): array

    {

        return $this->‪getVariableProcessor()

            ->‪inflateNamespaceParameters($parameters, $this->namespace);

    }

}