Sonata\AdminBundle\Route\DefaultRouteGenerator

Complexity

Total Complexity

24

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	generate()	0	4	1
A	generateUrl()	0	14	2
C	generateMenuUrl()	0	55	11
A	hasAdminRoute()	0	4	1
A	getCode()	0	26	5
A	loadCache()	0	16	3

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\AdminBundle\Route;

use Sonata\AdminBundle\Admin\AdminInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Routing\RouterInterface;

/**
 * @final since sonata-project/admin-bundle 3.52
 *
 * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
 */
class DefaultRouteGenerator implements RouteGeneratorInterface
{
    /**
     * @var RouterInterface
     */
    private $router;

    /**
     * @var RoutesCache
     */
    private $cache;

    /**
     * @var array
     */
    private $caches = [];

    /**
     * @var string[]
     */
    private $loaded = [];

    public function __construct(RouterInterface $router, RoutesCache $cache)
    {
        $this->router = $router;
        $this->cache = $cache;
    }

    public function generate($name, array $parameters = [], $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH)
    {
        return $this->router->generate($name, $parameters, $referenceType);
    }

    public function generateUrl(
        AdminInterface $admin,
        $name,
        array $parameters = [],
        $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH
    ) {
        $arrayRoute = $this->generateMenuUrl($admin, $name, $parameters, $referenceType);

        return $this->router->generate(
            $arrayRoute['route'],
            $arrayRoute['routeParameters'],
            $arrayRoute['routeAbsolute'] ? UrlGeneratorInterface::ABSOLUTE_URL : UrlGeneratorInterface::ABSOLUTE_PATH
        );
    }

    public function generateMenuUrl(
        AdminInterface $admin,
        $name,
        array $parameters = [],
        $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH
    ) {
        // if the admin is a child we automatically append the parent's id
        if ($admin->isChild() && $admin->hasRequest()) {
            // twig template does not accept variable hash key ... so cannot use admin.idparameter ...
            // switch value
            if (isset($parameters['id'])) {
                $parameters[$admin->getIdParameter()] = $parameters['id'];
                unset($parameters['id']);
            }

            $parentAdmin = $admin->getParent();
            while (null !== $parentAdmin) {
                $parameters[$parentAdmin->getIdParameter()] = $admin->getRequest()->attributes->get($parentAdmin->getIdParameter());
                $parentAdmin = $parentAdmin->isChild() ? $parentAdmin->getParent() : null;
            }
        }

        // if the admin is linked to a parent FieldDescription (ie, embedded widget)
        if ($admin->hasParentFieldDescription()) {
            // merge link parameter if any provided by the parent field
            $parameters = array_merge($parameters, $admin->getParentFieldDescription()->getOption('link_parameters', []));

            $parameters['uniqid'] = $admin->getUniqid();
            $parameters['code'] = $admin->getCode();
            $parameters['pcode'] = $admin->getParentFieldDescription()->getAdmin()->getCode();
            $parameters['puniqid'] = $admin->getParentFieldDescription()->getAdmin()->getUniqid();
        }

        if ('update' === $name || '|update' === substr($name, -7)) {
            $parameters['uniqid'] = $admin->getUniqid();
            $parameters['code'] = $admin->getCode();
        }

        // allows to define persistent parameters
        if ($admin->hasRequest()) {
            $parameters = array_merge($admin->getPersistentParameters(), $parameters);
        }

        $code = $this->getCode($admin, $name);

        if (!\array_key_exists($code, $this->caches)) {
            throw new \RuntimeException(sprintf('unable to find the route `%s`', $code));
        }

        return [
            'route' => $this->caches[$code],
            'routeParameters' => $parameters,
            'routeAbsolute' => UrlGeneratorInterface::ABSOLUTE_URL === $referenceType,
        ];
    }

    public function hasAdminRoute(AdminInterface $admin, $name)
    {
        return \array_key_exists($this->getCode($admin, $name), $this->caches);
    }

    private function getCode(AdminInterface $admin, string $name): string
    {
        $this->loadCache($admin);

        // someone provide the fullname
        if (!$admin->isChild() && \array_key_exists($name, $this->caches)) {
            return $name;
        }

        // NEXT_MAJOR: Uncomment the following line.
        // $codePrefix = $admin->getBaseCodeRoute();

        // NEXT_MAJOR: Remove next 5 lines.
        $codePrefix = $admin->getCode();

        if ($admin->isChild()) {
            $codePrefix = $admin->getBaseCodeRoute();
        }

        // someone provide a code, so it is a child
        if (strpos($name, '.')) {
            return $codePrefix.'|'.$name;
        }

        return $codePrefix.'.'.$name;
    }

    private function loadCache(AdminInterface $admin): void
    {
        if ($admin->isChild()) {
            $this->loadCache($admin->getParent());

It seems like $admin->getParent() can be null; however, loadCache() does not accept null, maybe add an additional type check?

            return;
        }

        if (\in_array($admin->getCode(), $this->loaded, true)) {
            return;
        }

        $this->caches = array_merge($this->cache->load($admin), $this->caches);

        $this->loaded[] = $admin->getCode();
    }
}