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

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\Controller\AbstractDashboardController;
  10. use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
  11. use EasyCorp\Bundle\EasyAdminBundle\Registry\DashboardControllerRegistry;
  12. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  14. /**
  15.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  16.  */
  17. final class AdminUrlGenerator implements AdminUrlGeneratorInterface
  18. {
  19.     private bool $isInitialized = false;
  20.     private AdminContextProvider $adminContextProvider;
  21.     private UrlGeneratorInterface $urlGenerator;
  22.     private DashboardControllerRegistry $dashboardControllerRegistry;
  23.     private AdminRouteGenerator $adminRouteGenerator;
  24.     private ?string $dashboardRoute = null;
  25.     private ?bool $includeReferrer = null;
  26.     private array $routeParameters = [];
  27.     private ?string $currentPageReferrer = null;
  28.     private ?string $customPageReferrer = null;
  30.     public function __construct(AdminContextProvider $adminContextProvider, UrlGeneratorInterface $urlGenerator, DashboardControllerRegistry $dashboardControllerRegistry, AdminRouteGenerator $adminRouteGenerator)
  31.     {
  32.         $this->adminContextProvider = $adminContextProvider;
  33.         $this->urlGenerator = $urlGenerator;
  34.         $this->dashboardControllerRegistry = $dashboardControllerRegistry;
  35.         $this->adminRouteGenerator = $adminRouteGenerator;
  36.     }
  38.     /**
  39.      * @return AdminUrlGenerator
  40.      */
  41.     public function setDashboard(string $dashboardControllerFqcn): AdminUrlGeneratorInterface
  42.     {
  43.         $this->setRouteParameter(EA::DASHBOARD_CONTROLLER_FQCN, $dashboardControllerFqcn);
  45.         return $this;
  46.     }
  48.     /**
  49.      * @return AdminUrlGenerator
  50.      */
  51.     public function setController(string $crudControllerFqcn): AdminUrlGeneratorInterface
  52.     {
  53.         $this->setRouteParameter(EA::CRUD_CONTROLLER_FQCN, $crudControllerFqcn);
  54.         $this->unset(EA::ROUTE_NAME);
  55.         $this->unset(EA::ROUTE_PARAMS);
  57.         return $this;
  58.     }
  60.     /**
  61.      * @return AdminUrlGenerator
  62.      */
  63.     public function setAction(string $action): AdminUrlGeneratorInterface
  64.     {
  65.         $this->setRouteParameter(EA::CRUD_ACTION, $action);
  66.         $this->unset(EA::ROUTE_NAME);
  67.         $this->unset(EA::ROUTE_PARAMS);
  69.         return $this;
  70.     }
  72.     /**
  73.      * @return AdminUrlGenerator
  74.      */
  75.     public function setRoute(string $routeName, array $routeParameters = []): AdminUrlGeneratorInterface
  76.     {
  77.         $this->unsetAllExcept(EA::DASHBOARD_CONTROLLER_FQCN);
  78.         $this->setRouteParameter(EA::ROUTE_NAME, $routeName);
  79.         $this->setRouteParameter(EA::ROUTE_PARAMS, $routeParameters);
  81.         return $this;
  82.     }
  84.     /**
  85.      * @return AdminUrlGenerator
  86.      */
  87.     public function setEntityId($entityId): AdminUrlGeneratorInterface
  88.     {
  89.         $this->setRouteParameter(EA::ENTITY_ID, $entityId);
  91.         return $this;
  92.     }
  94.     public function get(string $paramName): mixed
  95.     {
  96.         if (false === $this->isInitialized) {
  97.             $this->initialize();
  98.         }
  100.         return $this->routeParameters[$paramName] ?? null;
  101.     }
  103.     /**
  104.      * @return AdminUrlGenerator
  105.      */
  106.     public function set(string $paramName, $paramValue): AdminUrlGeneratorInterface
  107.     {
  108.         if (\in_array($paramName, [EA::MENU_INDEX, EA::SUBMENU_INDEX], true)) {
  109.             trigger_deprecation(
  110.                 'easycorp/easyadmin-bundle',
  111.                 '4.5.0',
  112.                 '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.',
  113.                 $paramName,
  114.             );
  115.         }
  117.         $this->setRouteParameter($paramName, $paramValue);
  119.         return $this;
  120.     }
  122.     /**
  123.      * @return AdminUrlGenerator
  124.      */
  125.     public function setAll(array $routeParameters): AdminUrlGeneratorInterface
  126.     {
  127.         foreach ($routeParameters as $paramName => $paramValue) {
  128.             $this->setRouteParameter($paramName, $paramValue);
  129.         }
  131.         return $this;
  132.     }
  134.     /**
  135.      * @return AdminUrlGenerator
  136.      */
  137.     public function unset(string $paramName): AdminUrlGeneratorInterface
  138.     {
  139.         if (false === $this->isInitialized) {
  140.             $this->initialize();
  141.         }
  143.         unset($this->routeParameters[$paramName]);
  145.         return $this;
  146.     }
  148.     /**
  149.      * @return AdminUrlGenerator
  150.      */
  151.     public function unsetAll(): AdminUrlGeneratorInterface
  152.     {
  153.         if (false === $this->isInitialized) {
  154.             $this->initialize();
  155.         }
  157.         $this->routeParameters = [];
  159.         return $this;
  160.     }
  162.     /**
  163.      * @return AdminUrlGenerator
  164.      */
  165.     public function unsetAllExcept(string ...$namesOfParamsToKeep): AdminUrlGeneratorInterface
  166.     {
  167.         if (false === $this->isInitialized) {
  168.             $this->initialize();
  169.         }
  171.         $this->routeParameters = array_intersect_key($this->routeParameters, array_flip($namesOfParamsToKeep));
  173.         return $this;
  174.     }
  176.     /**
  177.      * @return AdminUrlGenerator
  178.      */
  179.     public function includeReferrer(): AdminUrlGeneratorInterface
  180.     {
  181.         trigger_deprecation(
  182.             'easycorp/easyadmin-bundle',
  183.             '4.9.0',
  184.             '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.',
  185.         );
  187.         if (false === $this->isInitialized) {
  188.             $this->initialize();
  189.         }
  191.         $this->includeReferrer = true;
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return AdminUrlGenerator
  198.      */
  199.     public function removeReferrer(): AdminUrlGeneratorInterface
  200.     {
  201.         if (false === $this->isInitialized) {
  202.             $this->initialize();
  203.         }
  205.         $this->includeReferrer = false;
  207.         return $this;
  208.     }
  210.     /**
  211.      * @return AdminUrlGenerator
  212.      */
  213.     public function setReferrer(string $referrer): AdminUrlGeneratorInterface
  214.     {
  215.         trigger_deprecation(
  216.             'easycorp/easyadmin-bundle',
  217.             '4.9.0',
  218.             '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.',
  219.         );
  221.         if (false === $this->isInitialized) {
  222.             $this->initialize();
  223.         }
  225.         $this->includeReferrer = true;
  226.         $this->customPageReferrer = $referrer;
  228.         return $this;
  229.     }
  231.     /**
  232.      * @return AdminUrlGenerator
  233.      */
  234.     public function addSignature(bool $addSignature = true): AdminUrlGeneratorInterface
  235.     {
  236.         trigger_deprecation(
  237.             'easycorp/easyadmin-bundle',
  238.             '4.1.0',
  239.             '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.',
  240.             __METHOD__,
  241.         );
  243.         return $this;
  244.     }
  246.     public function getSignature(): string
  247.     {
  248.         trigger_deprecation(
  249.             'easycorp/easyadmin-bundle',
  250.             '4.1.0',
  251.             '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.',
  252.             __METHOD__,
  253.         );
  255.         return '';
  256.     }
  258.     // this method allows to omit the 'generateUrl()' call in templates, making code more concise
  259.     public function __toString(): string
  260.     {
  261.         return $this->generateUrl();
  262.     }
  264.     public function generateUrl(): string
  265.     {
  266.         if (false === $this->isInitialized) {
  267.             $this->initialize();
  268.         }
  270.         if (true === $this->includeReferrer) {
  271.             $this->setRouteParameter(EA::REFERRER, $this->customPageReferrer ?? $this->currentPageReferrer);
  272.         }
  274.         // this avoids forcing users to always be explicit about the action to execute
  275.         if (null !== $this->get(EA::CRUD_CONTROLLER_FQCN) && null === $this->get(EA::CRUD_ACTION)) {
  276.             $this->set(EA::CRUD_ACTION, Action::INDEX);
  277.         }
  279.         // if the Dashboard FQCN is defined, find its route and use it to override
  280.         // the current route (this is needed to allow generating links to different dashboards)
  281.         if (null !== $dashboardControllerFqcn = $this->get(EA::DASHBOARD_CONTROLLER_FQCN)) {
  282.             if (null === $dashboardRoute = $this->dashboardControllerRegistry->getRouteByControllerFqcn($dashboardControllerFqcn)) {
  283.                 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));
  284.             }
  286.             $this->dashboardRoute = $dashboardRoute;
  287.             $this->unset(EA::DASHBOARD_CONTROLLER_FQCN);
  288.         }
  290.         // if the current action is 'index' and an entity ID is defined, remove the entity ID to prevent exceptions automatically
  291.         if (Action::INDEX === $this->get(EA::CRUD_ACTION) && null !== $this->get(EA::ENTITY_ID)) {
  292.             $this->unset(EA::ENTITY_ID);
  293.         }
  295.         // this happens when generating URLs from outside EasyAdmin (AdminContext is null) and
  296.         // no Dashboard FQCN has been defined explicitly
  297.         if (null === $this->dashboardRoute) {
  298.             if ($this->dashboardControllerRegistry->getNumberOfDashboards() > 1) {
  299.                 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.');
  300.             }
  302.             $this->setDashboard($this->dashboardControllerRegistry->getFirstDashboardFqcn());
  303.             $this->dashboardRoute = $this->dashboardControllerRegistry->getFirstDashboardRoute();
  304.         }
  306.         // if present, remove the suffix of i18n route names (it's the content after the last dot
  307.         // in the route name; e.g. 'dashboard.en' -> remove '.en', 'admin.index.en_US' -> remove '.en_US')
  308.         $this->dashboardRoute = preg_replace('~\.[a-z]{2}(_[A-Z]{2})?$~', '', $this->dashboardRoute);
  310.         // this removes any parameter with a NULL value
  311.         $routeParameters = array_filter(
  312.             $this->routeParameters,
  313.             static fn ($parameterValue): bool => null !== $parameterValue
  314.         );
  315.         ksort($routeParameters, \SORT_STRING);
  317.         $context = $this->adminContextProvider->getContext();
  318.         $usePrettyUrls = null !== $context && $context->usePrettyUrls();
  319.         $urlType = null !== $context && false === $context->getAbsoluteUrls() ? UrlGeneratorInterface::ABSOLUTE_PATH : UrlGeneratorInterface::ABSOLUTE_URL;
  321.         if (null !== $this->get(EA::ROUTE_NAME)) {
  322.             return $this->urlGenerator->generate($this->dashboardRoute, $routeParameters, $urlType);
  323.         }
  325.         if ($usePrettyUrls) {
  326.             $dashboardControllerFqcn = $this->get(EA::DASHBOARD_CONTROLLER_FQCN) ?? $context->getRequest()->attributes->get(EA::DASHBOARD_CONTROLLER_FQCN) ?? $this->dashboardControllerRegistry->getFirstDashboardFqcn();
  327.             $crudControllerFqcn = $this->get(EA::CRUD_CONTROLLER_FQCN) ?? $context->getRequest()->attributes->get(EA::CRUD_CONTROLLER_FQCN);
  328.             $actionName = $this->get(EA::CRUD_ACTION) ?? $context->getRequest()->attributes->get(EA::CRUD_ACTION);
  330.             if (null === $crudControllerFqcn || null === $routeName = $this->adminRouteGenerator->findRouteName($dashboardControllerFqcn, $crudControllerFqcn, $actionName)) {
  331.                 $routeName = $this->dashboardRoute;
  332.             } else {
  333.                 // remove these parameters so they don't appear in the query string when using pretty URLs
  334.                 unset($routeParameters[EA::DASHBOARD_CONTROLLER_FQCN]);
  335.                 unset($routeParameters[EA::CRUD_CONTROLLER_FQCN]);
  336.                 unset($routeParameters[EA::CRUD_ACTION]);
  337.                 unset($routeParameters[EA::ENTITY_FQCN]);
  338.             }
  339.         } else {
  340.             $routeName = $this->dashboardRoute;
  341.         }
  343.         if (!$usePrettyUrls && \in_array($routeParameters[EA::CRUD_ACTION] ?? Action::INDEX, Crud::ACTION_NAMES, true)) {
  344.             trigger_deprecation(
  345.                 'easycorp/easyadmin-bundle',
  346.                 '4.14.0',
  347.                 '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.',
  348.             );
  349.         }
  351.         $url = $this->urlGenerator->generate($routeName, $routeParameters, $urlType);
  352.         $url = '' === $url ? '?' : $url;
  354.         // this is important to start the generation of each URL from the same initial state
  355.         // otherwise, some parameters used when generating some URL could leak to other URLs
  356.         $this->isInitialized = false;
  358.         return $url;
  359.     }
  361.     private function setRouteParameter(string $paramName, $paramValue): void
  362.     {
  363.         if (false === $this->isInitialized) {
  364.             $this->initialize();
  365.         }
  367.         if (\is_resource($paramValue)) {
  368.             throw new \InvalidArgumentException(sprintf('The value of the "%s" parameter is a PHP resource, which is not supported as a route parameter.', $paramName));
  369.         }
  371.         if (\is_object($paramValue)) {
  372.             if (method_exists($paramValue, '__toString')) {
  373.                 $paramValue = (string) $paramValue;
  374.             } else {
  375.                 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));
  376.             }
  377.         }
  379.         $this->routeParameters[$paramName] = $paramValue;
  380.     }
  382.     private function initialize(): void
  383.     {
  384.         $this->isInitialized = true;
  386.         $adminContext = $this->adminContextProvider->getContext();
  388.         if (null === $adminContext) {
  389.             $this->dashboardRoute = null;
  390.             $currentRouteParameters = $routeParametersForReferrer = [];
  391.             $this->currentPageReferrer = null;
  392.         } else {
  393.             $this->dashboardRoute = $adminContext->getDashboardRouteName();
  394.             $currentRouteParameters = $routeParametersForReferrer = $adminContext->getRequest()->query->all();
  395.             unset($routeParametersForReferrer[EA::REFERRER]);
  396.             $this->currentPageReferrer = sprintf('%s%s?%s', $adminContext->getRequest()->getBaseUrl(), $adminContext->getRequest()->getPathInfo(), http_build_query($routeParametersForReferrer));
  397.         }
  399.         $this->includeReferrer = null;
  400.         $this->customPageReferrer = null;
  402.         $this->routeParameters = $currentRouteParameters;
  403.     }
  404. }