vendor/easycorp/easyadmin-bundle/src/Router/AdminUrlGenerator.php line 317

Open in your IDE?
  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Router;
  5. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  6. use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
  7. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
  8. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Controller\DashboardControllerInterface;
  9. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Provider\AdminContextProviderInterface;
  10. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Router\AdminRouteGeneratorInterface;
  11. use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractDashboardController;
  12. use EasyCorp\Bundle\EasyAdminBundle\Registry\DashboardControllerRegistryInterface;
  13. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  15. /**
  16.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  17.  */
  18. final class AdminUrlGenerator implements AdminUrlGeneratorInterface
  19. {
  20.     private bool $isInitialized = false;
  21.     private ?string $dashboardRoute = null;
  22.     private ?bool $includeReferrer = null;
  23.     private array $routeParameters = [];
  24.     private ?string $currentPageReferrer = null;
  25.     private ?string $customPageReferrer = null;
  27.     public function __construct(
  28.         private readonly AdminContextProviderInterface $adminContextProvider,
  29.         private readonly UrlGeneratorInterface $urlGenerator,
  30.         private readonly DashboardControllerRegistryInterface $dashboardControllerRegistry,
  31.         private readonly AdminRouteGeneratorInterface $adminRouteGenerator,
  32.     ) {
  33.     }
  35.     public function setDashboard(string $dashboardControllerFqcn): AdminUrlGeneratorInterface
  36.     {
  37.         $this->setRouteParameter(EA::DASHBOARD_CONTROLLER_FQCN, $dashboardControllerFqcn);
  39.         return $this;
  40.     }
  42.     public function setController(string $crudControllerFqcn): AdminUrlGeneratorInterface
  43.     {
  44.         $this->setRouteParameter(EA::CRUD_CONTROLLER_FQCN, $crudControllerFqcn);
  45.         $this->unset(EA::ROUTE_NAME);
  46.         $this->unset(EA::ROUTE_PARAMS);
  48.         return $this;
  49.     }
  51.     public function setAction(string $action): AdminUrlGeneratorInterface
  52.     {
  53.         $this->setRouteParameter(EA::CRUD_ACTION, $action);
  54.         $this->unset(EA::ROUTE_NAME);
  55.         $this->unset(EA::ROUTE_PARAMS);
  57.         return $this;
  58.     }
  60.     public function setRoute(string $routeName, array $routeParameters = []): AdminUrlGeneratorInterface
  61.     {
  62.         $this->unsetAllExcept(EA::DASHBOARD_CONTROLLER_FQCN);
  63.         $this->setRouteParameter(EA::ROUTE_NAME, $routeName);
  64.         $this->setRouteParameter(EA::ROUTE_PARAMS, $routeParameters);
  66.         return $this;
  67.     }
  69.     public function setEntityId($entityId): AdminUrlGeneratorInterface
  70.     {
  71.         $this->setRouteParameter(EA::ENTITY_ID, $entityId);
  73.         return $this;
  74.     }
  76.     public function get(string $paramName): mixed
  77.     {
  78.         if (false === $this->isInitialized) {
  79.             $this->initialize();
  80.         }
  82.         return $this->routeParameters[$paramName] ?? null;
  83.     }
  85.     public function set(string $paramName, $paramValue): AdminUrlGeneratorInterface
  86.     {
  87.         if (\in_array($paramName, [EA::MENU_INDEX, EA::SUBMENU_INDEX], true)) {
  88.             trigger_deprecation(
  89.                 'easycorp/easyadmin-bundle',
  90.                 '4.5.0',
  91.                 'Using the "%s" query parameter is deprecated. Menu items are now highlighted automatically based on the Request data, so you don\'t have to deal with menu items manually anymore.',
  92.                 $paramName,
  93.             );
  94.         }
  96.         $this->setRouteParameter($paramName, $paramValue);
  98.         return $this;
  99.     }
  101.     public function setAll(array $routeParameters): AdminUrlGeneratorInterface
  102.     {
  103.         foreach ($routeParameters as $paramName => $paramValue) {
  104.             $this->setRouteParameter($paramName, $paramValue);
  105.         }
  107.         return $this;
  108.     }
  110.     public function unset(string $paramName): AdminUrlGeneratorInterface
  111.     {
  112.         if (false === $this->isInitialized) {
  113.             $this->initialize();
  114.         }
  116.         unset($this->routeParameters[$paramName]);
  118.         return $this;
  119.     }
  121.     public function unsetAll(): AdminUrlGeneratorInterface
  122.     {
  123.         if (false === $this->isInitialized) {
  124.             $this->initialize();
  125.         }
  127.         $this->routeParameters = [];
  129.         return $this;
  130.     }
  132.     public function unsetAllExcept(string ...$namesOfParamsToKeep): AdminUrlGeneratorInterface
  133.     {
  134.         if (false === $this->isInitialized) {
  135.             $this->initialize();
  136.         }
  138.         $this->routeParameters = array_intersect_key($this->routeParameters, array_flip($namesOfParamsToKeep));
  140.         return $this;
  141.     }
  143.     public function includeReferrer(): AdminUrlGeneratorInterface
  144.     {
  145.         trigger_deprecation(
  146.             'easycorp/easyadmin-bundle',
  147.             '4.9.0',
  148.             'Adding the referrer argument in the admin URLs via the AdminUrlGenerator::includeReferrer() method is deprecated and it will be removed in 5.0.0. The referrer will now be determined automatically based on the current request.',
  149.         );
  151.         if (false === $this->isInitialized) {
  152.             $this->initialize();
  153.         }
  155.         $this->includeReferrer = true;
  157.         return $this;
  158.     }
  160.     public function removeReferrer(): AdminUrlGeneratorInterface
  161.     {
  162.         trigger_deprecation(
  163.             'easycorp/easyadmin-bundle',
  164.             '4.9.0',
  165.             'Removing the referrer argument in the admin URLs via the AdminUrlGenerator::removeReferrer() method is deprecated and it will be removed in 5.0.0. The referrer will now be determined automatically based on the current request.',
  166.         );
  168.         if (false === $this->isInitialized) {
  169.             $this->initialize();
  170.         }
  172.         $this->includeReferrer = false;
  174.         return $this;
  175.     }
  177.     public function setReferrer(string $referrer): AdminUrlGeneratorInterface
  178.     {
  179.         trigger_deprecation(
  180.             'easycorp/easyadmin-bundle',
  181.             '4.9.0',
  182.             'Adding the referrer argument in the admin URLs via the AdminUrlGenerator::setReferrer() method is deprecated and it will be removed in 5.0.0. The referrer will now be determined automatically based on the current request.',
  183.         );
  185.         if (false === $this->isInitialized) {
  186.             $this->initialize();
  187.         }
  189.         $this->includeReferrer = true;
  190.         $this->customPageReferrer = $referrer;
  192.         return $this;
  193.     }
  195.     public function addSignature(bool $addSignature = true): AdminUrlGeneratorInterface
  196.     {
  197.         trigger_deprecation(
  198.             'easycorp/easyadmin-bundle',
  199.             '4.1.0',
  200.             'EasyAdmin URLs no longer include signatures because they don\'t provide any additional security. Calling the "%s" method has no effect, so you can stop calling it. This method will be removed in future EasyAdmin versions.',
  201.             __METHOD__,
  202.         );
  204.         return $this;
  205.     }
  207.     public function getSignature(): string
  208.     {
  209.         trigger_deprecation(
  210.             'easycorp/easyadmin-bundle',
  211.             '4.1.0',
  212.             'EasyAdmin URLs no longer include signatures because they don\'t provide any additional security. Calling the "%s" method will always return an empty string, so you can stop calling it. This method will be removed in future EasyAdmin versions.',
  213.             __METHOD__,
  214.         );
  216.         return '';
  217.     }
  219.     // this method allows to omit the 'generateUrl()' call in templates, making code more concise
  220.     public function __toString(): string
  221.     {
  222.         return $this->generateUrl();
  223.     }
  225.     public function generateUrl(): string
  226.     {
  227.         if (false === $this->isInitialized) {
  228.             $this->initialize();
  229.         }
  231.         $usePrettyUrls = $this->adminRouteGenerator->usesPrettyUrls();
  233.         if (true === $this->includeReferrer) {
  234.             $this->setRouteParameter(EA::REFERRER, $this->customPageReferrer ?? $this->currentPageReferrer);
  235.         }
  237.         // this avoids forcing users to always be explicit about the action to execute
  238.         if (null !== $this->get(EA::CRUD_CONTROLLER_FQCN) && null === $this->get(EA::CRUD_ACTION)) {
  239.             $this->set(EA::CRUD_ACTION, Action::INDEX);
  240.         }
  242.         // if the Dashboard FQCN is defined, find its route and use it to override
  243.         // the current route (this is needed to allow generating links to different dashboards)
  244.         if (null !== $dashboardControllerFqcn = $this->get(EA::DASHBOARD_CONTROLLER_FQCN)) {
  245.             if (null === $dashboardRoute = $this->dashboardControllerRegistry->getRouteByControllerFqcn($dashboardControllerFqcn)) {
  246.                 throw new \InvalidArgumentException(sprintf('The given "%s" class is not a valid Dashboard controller. Make sure it extends from "%s" or implements "%s".', $dashboardControllerFqcn, AbstractDashboardController::class, DashboardControllerInterface::class));
  247.             }
  249.             $this->dashboardRoute = $dashboardRoute;
  250.             if (!$usePrettyUrls) {
  251.                 $this->unset(EA::DASHBOARD_CONTROLLER_FQCN);
  252.             }
  253.         }
  255.         // if the current action is 'index' and an entity ID is defined, remove the entity ID to prevent exceptions automatically
  256.         if (Action::INDEX === $this->get(EA::CRUD_ACTION) && null !== $this->get(EA::ENTITY_ID)) {
  257.             $this->unset(EA::ENTITY_ID);
  258.         }
  260.         // this happens when generating URLs from outside EasyAdmin (AdminContext is null) and
  261.         // no Dashboard FQCN has been defined explicitly
  262.         if (null === $this->dashboardRoute) {
  263.             if ($this->dashboardControllerRegistry->getNumberOfDashboards() > 1) {
  264.                 throw new \RuntimeException('When generating admin URLs from outside EasyAdmin or without a related HTTP request (e.g. in tests, console commands, etc.), if your application has more than one Dashboard, you must associate the URL to a specific Dashboard using the "setDashboard()" method.');
  265.             }
  267.             $this->setDashboard($this->dashboardControllerRegistry->getFirstDashboardFqcn());
  268.             $this->dashboardRoute = $this->dashboardControllerRegistry->getFirstDashboardRoute();
  269.         }
  271.         // if present, remove the suffix of i18n route names (it's the content after the last dot
  272.         // in the route name; e.g. 'dashboard.en' -> remove '.en', 'admin.index.en_US' -> remove '.en_US')
  273.         $this->dashboardRoute = preg_replace('~\.[a-z]{2}(_[A-Z]{2})?$~', '', $this->dashboardRoute);
  275.         // this removes any parameter with a NULL value
  276.         $routeParameters = array_filter(
  277.             $this->routeParameters,
  278.             static fn ($parameterValue): bool => null !== $parameterValue
  279.         );
  280.         ksort($routeParameters, \SORT_STRING);
  282.         $context = $this->adminContextProvider->getContext();
  283.         $urlType = null !== $context && false === $context->getAbsoluteUrls() ? UrlGeneratorInterface::ABSOLUTE_PATH : UrlGeneratorInterface::ABSOLUTE_URL;
  285.         // if no route parameters are passed, the route doesn't point to any CRUD controller
  286.         // action or to any custom action/route; consider it a link to the current dashboard
  287.         if ([] === $routeParameters) {
  288.             return $this->urlGenerator->generate($this->dashboardRoute, [], $urlType);
  289.         }
  291.         if (null !== $this->get(EA::ROUTE_NAME)) {
  292.             return $this->urlGenerator->generate($this->dashboardRoute, $routeParameters, $urlType);
  293.         }
  295.         if ($usePrettyUrls) {
  296.             $dashboardControllerFqcn = $this->get(EA::DASHBOARD_CONTROLLER_FQCN) ?? $context?->getRequest()->attributes->get(EA::DASHBOARD_CONTROLLER_FQCN) ?? $context?->getDashboardControllerFqcn() ?? $this->dashboardControllerRegistry->getFirstDashboardFqcn();
  297.             $crudControllerFqcn = $this->get(EA::CRUD_CONTROLLER_FQCN) ?? $context?->getRequest()->attributes->get(EA::CRUD_CONTROLLER_FQCN);
  298.             $actionName = $this->get(EA::CRUD_ACTION) ?? $context?->getRequest()->attributes->get(EA::CRUD_ACTION);
  300.             if (null === $crudControllerFqcn || null === $routeName = $this->adminRouteGenerator->findRouteName($dashboardControllerFqcn, $crudControllerFqcn, $actionName)) {
  301.                 $routeName = $this->dashboardRoute;
  302.                 if (null === $crudControllerFqcn) {
  303.                     unset($routeParameters[EA::DASHBOARD_CONTROLLER_FQCN]);
  304.                 }
  305.             } else {
  306.                 // remove these parameters so they don't appear in the query string when using pretty URLs
  307.                 unset($routeParameters[EA::DASHBOARD_CONTROLLER_FQCN]);
  308.                 unset($routeParameters[EA::CRUD_CONTROLLER_FQCN]);
  309.                 unset($routeParameters[EA::CRUD_ACTION]);
  310.                 unset($routeParameters[EA::ENTITY_FQCN]);
  311.             }
  312.         } else {
  313.             $routeName = $this->dashboardRoute;
  314.         }
  316.         if (!$usePrettyUrls && \in_array($routeParameters[EA::CRUD_ACTION] ?? Action::INDEX, Crud::ACTION_NAMES, true)) {
  317.             trigger_deprecation(
  318.                 'easycorp/easyadmin-bundle',
  319.                 '4.14.0',
  320.                 'Not using pretty admin URLs is deprecated because they will become the only available URLs starting from EasyAdmin 5.0.0. Read the docs to learn how to enable pretty URLs in your application.',
  321.             );
  322.         }
  324.         $url = $this->urlGenerator->generate($routeName, $routeParameters, $urlType);
  325.         $url = '' === $url ? '?' : $url;
  327.         // this is important to start the generation of each URL from the same initial state
  328.         // otherwise, some parameters used when generating some URL could leak to other URLs
  329.         $this->isInitialized = false;
  331.         return $url;
  332.     }
  334.     private function setRouteParameter(string $paramName, $paramValue): void
  335.     {
  336.         if (false === $this->isInitialized) {
  337.             $this->initialize();
  338.         }
  340.         if (\is_resource($paramValue)) {
  341.             throw new \InvalidArgumentException(sprintf('The value of the "%s" parameter is a PHP resource, which is not supported as a route parameter.', $paramName));
  342.         }
  344.         if (\is_object($paramValue)) {
  345.             if (method_exists($paramValue, '__toString')) {
  346.                 $paramValue = (string) $paramValue;
  347.             } else {
  348.                 throw new \InvalidArgumentException(sprintf('The object passed as the value of the "%s" parameter must implement the "__toString()" method to allow using its value as a route parameter.', $paramName));
  349.             }
  350.         }
  352.         $this->routeParameters[$paramName] = $paramValue;
  353.     }
  355.     private function initialize(): void
  356.     {
  357.         $this->isInitialized = true;
  359.         $adminContext = $this->adminContextProvider->getContext();
  361.         if (null === $adminContext) {
  362.             $this->dashboardRoute = null;
  363.             $currentRouteParameters = $routeParametersForReferrer = [];
  364.             $this->currentPageReferrer = null;
  365.         } else {
  366.             $this->dashboardRoute = $adminContext->getDashboardRouteName();
  367.             $routeParameters = array_filter([
  368.                 EA::DASHBOARD_CONTROLLER_FQCN => $adminContext->getRequest()->attributes->get(EA::DASHBOARD_CONTROLLER_FQCN),
  369.                 EA::CRUD_CONTROLLER_FQCN => $adminContext->getRequest()->attributes->get(EA::CRUD_CONTROLLER_FQCN),
  370.                 EA::CRUD_ACTION => $adminContext->getRequest()->attributes->get(EA::CRUD_ACTION),
  371.                 EA::ENTITY_ID => $adminContext->getRequest()->attributes->get(EA::ENTITY_ID),
  372.             ]);
  373.             $currentRouteParameters = $routeParametersForReferrer = array_merge($routeParameters, $adminContext->getRequest()->query->all());
  374.             unset($routeParametersForReferrer[EA::REFERRER]);
  375.             $this->currentPageReferrer = sprintf('%s%s?%s', $adminContext->getRequest()->getBaseUrl(), $adminContext->getRequest()->getPathInfo(), http_build_query($routeParametersForReferrer));
  376.         }
  378.         $this->includeReferrer = null;
  379.         $this->customPageReferrer = null;
  381.         $this->routeParameters = $currentRouteParameters;
  382.     }
  383. }