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

  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Router;
  5. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  6. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
  7. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Controller\DashboardControllerInterface;
  8. use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractDashboardController;
  9. use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
  10. use EasyCorp\Bundle\EasyAdminBundle\Registry\DashboardControllerRegistry;
  11. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  13. /**
  14.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  15.  */
  16. final class AdminUrlGenerator implements AdminUrlGeneratorInterface
  17. {
  18.     private bool $isInitialized = false;
  19.     private AdminContextProvider $adminContextProvider;
  20.     private UrlGeneratorInterface $urlGenerator;
  21.     private DashboardControllerRegistry $dashboardControllerRegistry;
  22.     private ?string $dashboardRoute = null;
  23.     private ?bool $includeReferrer = null;
  24.     private array $routeParameters = [];
  25.     private ?string $currentPageReferrer = null;
  26.     private ?string $customPageReferrer = null;
  28.     public function __construct(AdminContextProvider $adminContextProvider, UrlGeneratorInterface $urlGenerator, DashboardControllerRegistry $dashboardControllerRegistry)
  29.     {
  30.         $this->adminContextProvider = $adminContextProvider;
  31.         $this->urlGenerator = $urlGenerator;
  32.         $this->dashboardControllerRegistry = $dashboardControllerRegistry;
  33.     }
  35.     /**
  36.      * @return AdminUrlGenerator
  37.      */
  38.     public function setDashboard(string $dashboardControllerFqcn): AdminUrlGeneratorInterface
  39.     {
  40.         $this->setRouteParameter(EA::DASHBOARD_CONTROLLER_FQCN, $dashboardControllerFqcn);
  42.         return $this;
  43.     }
  45.     /**
  46.      * @return AdminUrlGenerator
  47.      */
  48.     public function setController(string $crudControllerFqcn): AdminUrlGeneratorInterface
  49.     {
  50.         $this->setRouteParameter(EA::CRUD_CONTROLLER_FQCN, $crudControllerFqcn);
  51.         $this->unset(EA::ROUTE_NAME);
  52.         $this->unset(EA::ROUTE_PARAMS);
  54.         return $this;
  55.     }
  57.     /**
  58.      * @return AdminUrlGenerator
  59.      */
  60.     public function setAction(string $action): AdminUrlGeneratorInterface
  61.     {
  62.         $this->setRouteParameter(EA::CRUD_ACTION, $action);
  63.         $this->unset(EA::ROUTE_NAME);
  64.         $this->unset(EA::ROUTE_PARAMS);
  66.         return $this;
  67.     }
  69.     /**
  70.      * @return AdminUrlGenerator
  71.      */
  72.     public function setRoute(string $routeName, array $routeParameters = []): AdminUrlGeneratorInterface
  73.     {
  74.         $this->unsetAllExcept(EA::DASHBOARD_CONTROLLER_FQCN);
  75.         $this->setRouteParameter(EA::ROUTE_NAME, $routeName);
  76.         $this->setRouteParameter(EA::ROUTE_PARAMS, $routeParameters);
  78.         return $this;
  79.     }
  81.     /**
  82.      * @return AdminUrlGenerator
  83.      */
  84.     public function setEntityId($entityId): AdminUrlGeneratorInterface
  85.     {
  86.         $this->setRouteParameter(EA::ENTITY_ID, $entityId);
  88.         return $this;
  89.     }
  91.     public function get(string $paramName): mixed
  92.     {
  93.         if (false === $this->isInitialized) {
  94.             $this->initialize();
  95.         }
  97.         return $this->routeParameters[$paramName] ?? null;
  98.     }
  100.     /**
  101.      * @return AdminUrlGenerator
  102.      */
  103.     public function set(string $paramName, $paramValue): AdminUrlGeneratorInterface
  104.     {
  105.         if (\in_array($paramName, [EA::MENU_INDEX, EA::SUBMENU_INDEX], true)) {
  106.             trigger_deprecation(
  107.                 'easycorp/easyadmin-bundle',
  108.                 '4.5.0',
  109.                 '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.',
  110.                 $paramName,
  111.             );
  112.         }
  114.         $this->setRouteParameter($paramName, $paramValue);
  116.         return $this;
  117.     }
  119.     /**
  120.      * @return AdminUrlGenerator
  121.      */
  122.     public function setAll(array $routeParameters): AdminUrlGeneratorInterface
  123.     {
  124.         foreach ($routeParameters as $paramName => $paramValue) {
  125.             $this->setRouteParameter($paramName, $paramValue);
  126.         }
  128.         return $this;
  129.     }
  131.     /**
  132.      * @return AdminUrlGenerator
  133.      */
  134.     public function unset(string $paramName): AdminUrlGeneratorInterface
  135.     {
  136.         if (false === $this->isInitialized) {
  137.             $this->initialize();
  138.         }
  140.         unset($this->routeParameters[$paramName]);
  142.         return $this;
  143.     }
  145.     /**
  146.      * @return AdminUrlGenerator
  147.      */
  148.     public function unsetAll(): AdminUrlGeneratorInterface
  149.     {
  150.         if (false === $this->isInitialized) {
  151.             $this->initialize();
  152.         }
  154.         $this->routeParameters = [];
  156.         return $this;
  157.     }
  159.     /**
  160.      * @return AdminUrlGenerator
  161.      */
  162.     public function unsetAllExcept(string ...$namesOfParamsToKeep): AdminUrlGeneratorInterface
  163.     {
  164.         if (false === $this->isInitialized) {
  165.             $this->initialize();
  166.         }
  168.         $this->routeParameters = array_intersect_key($this->routeParameters, array_flip($namesOfParamsToKeep));
  170.         return $this;
  171.     }
  173.     /**
  174.      * @return AdminUrlGenerator
  175.      */
  176.     public function includeReferrer(): AdminUrlGeneratorInterface
  177.     {
  178.         trigger_deprecation(
  179.             'easycorp/easyadmin-bundle',
  180.             '4.9.0',
  181.             '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.',
  182.         );
  184.         if (false === $this->isInitialized) {
  185.             $this->initialize();
  186.         }
  188.         $this->includeReferrer = true;
  190.         return $this;
  191.     }
  193.     /**
  194.      * @return AdminUrlGenerator
  195.      */
  196.     public function removeReferrer(): AdminUrlGeneratorInterface
  197.     {
  198.         if (false === $this->isInitialized) {
  199.             $this->initialize();
  200.         }
  202.         $this->includeReferrer = false;
  204.         return $this;
  205.     }
  207.     /**
  208.      * @return AdminUrlGenerator
  209.      */
  210.     public function setReferrer(string $referrer): AdminUrlGeneratorInterface
  211.     {
  212.         trigger_deprecation(
  213.             'easycorp/easyadmin-bundle',
  214.             '4.9.0',
  215.             '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.',
  216.         );
  218.         if (false === $this->isInitialized) {
  219.             $this->initialize();
  220.         }
  222.         $this->includeReferrer = true;
  223.         $this->customPageReferrer = $referrer;
  225.         return $this;
  226.     }
  228.     /**
  229.      * @return AdminUrlGenerator
  230.      */
  231.     public function addSignature(bool $addSignature = true): AdminUrlGeneratorInterface
  232.     {
  233.         trigger_deprecation(
  234.             'easycorp/easyadmin-bundle',
  235.             '4.1.0',
  236.             '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.',
  237.             __METHOD__,
  238.         );
  240.         return $this;
  241.     }
  243.     public function getSignature(): string
  244.     {
  245.         trigger_deprecation(
  246.             'easycorp/easyadmin-bundle',
  247.             '4.1.0',
  248.             '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.',
  249.             __METHOD__,
  250.         );
  252.         return '';
  253.     }
  255.     // this method allows to omit the 'generateUrl()' call in templates, making code more concise
  256.     public function __toString(): string
  257.     {
  258.         return $this->generateUrl();
  259.     }
  261.     public function generateUrl(): string
  262.     {
  263.         if (false === $this->isInitialized) {
  264.             $this->initialize();
  265.         }
  267.         if (true === $this->includeReferrer) {
  268.             $this->setRouteParameter(EA::REFERRER, $this->customPageReferrer ?? $this->currentPageReferrer);
  269.         }
  271.         // this avoids forcing users to always be explicit about the action to execute
  272.         if (null !== $this->get(EA::CRUD_CONTROLLER_FQCN) && null === $this->get(EA::CRUD_ACTION)) {
  273.             $this->set(EA::CRUD_ACTION, Action::INDEX);
  274.         }
  276.         // if the Dashboard FQCN is defined, find its route and use it to override
  277.         // the current route (this is needed to allow generating links to different dashboards)
  278.         if (null !== $dashboardControllerFqcn = $this->get(EA::DASHBOARD_CONTROLLER_FQCN)) {
  279.             if (null === $dashboardRoute = $this->dashboardControllerRegistry->getRouteByControllerFqcn($dashboardControllerFqcn)) {
  280.                 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));
  281.             }
  283.             $this->dashboardRoute = $dashboardRoute;
  284.             $this->unset(EA::DASHBOARD_CONTROLLER_FQCN);
  285.         }
  287.         // this happens when generating URLs from outside EasyAdmin (AdminContext is null) and
  288.         // no Dashboard FQCN has been defined explicitly
  289.         if (null === $this->dashboardRoute) {
  290.             if ($this->dashboardControllerRegistry->getNumberOfDashboards() > 1) {
  291.                 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.');
  292.             }
  294.             $this->dashboardRoute = $this->dashboardControllerRegistry->getFirstDashboardRoute();
  295.         }
  297.         // if present, remove the suffix of i18n route names (it's the content after the last dot
  298.         // in the route name; e.g. 'dashboard.en' -> remove '.en', 'admin.index.en_US' -> remove '.en_US')
  299.         $this->dashboardRoute = preg_replace('~\.[a-z]{2}(_[A-Z]{2})?$~', '', $this->dashboardRoute);
  301.         // this removes any parameter with a NULL value
  302.         $routeParameters = array_filter(
  303.             $this->routeParameters,
  304.             static fn ($parameterValue): bool => null !== $parameterValue
  305.         );
  306.         ksort($routeParameters, \SORT_STRING);
  308.         $context = $this->adminContextProvider->getContext();
  309.         $urlType = null !== $context && false === $context->getAbsoluteUrls() ? UrlGeneratorInterface::RELATIVE_PATH : UrlGeneratorInterface::ABSOLUTE_URL;
  310.         $url = $this->urlGenerator->generate($this->dashboardRoute, $routeParameters, $urlType);
  311.         $url = '' === $url ? '?' : $url;
  313.         // this is important to start the generation a each URL from the same initial state
  314.         // otherwise, some parameters used when generating some URL could leak to other URLs
  315.         $this->isInitialized = false;
  317.         return $url;
  318.     }
  320.     private function setRouteParameter(string $paramName, $paramValue): void
  321.     {
  322.         if (false === $this->isInitialized) {
  323.             $this->initialize();
  324.         }
  326.         if (\is_resource($paramValue)) {
  327.             throw new \InvalidArgumentException(sprintf('The value of the "%s" parameter is a PHP resource, which is not supported as a route parameter.', $paramName));
  328.         }
  330.         if (\is_object($paramValue)) {
  331.             if (method_exists($paramValue, '__toString')) {
  332.                 $paramValue = (string) $paramValue;
  333.             } else {
  334.                 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));
  335.             }
  336.         }
  338.         $this->routeParameters[$paramName] = $paramValue;
  339.     }
  341.     private function initialize(): void
  342.     {
  343.         $this->isInitialized = true;
  345.         $adminContext = $this->adminContextProvider->getContext();
  347.         if (null === $adminContext) {
  348.             $this->dashboardRoute = null;
  349.             $currentRouteParameters = $routeParametersForReferrer = [];
  350.             $this->currentPageReferrer = null;
  351.         } else {
  352.             $this->dashboardRoute = $adminContext->getDashboardRouteName();
  353.             $currentRouteParameters = $routeParametersForReferrer = $adminContext->getRequest()->query->all();
  354.             unset($routeParametersForReferrer[EA::REFERRER]);
  355.             $this->currentPageReferrer = sprintf('%s%s?%s', $adminContext->getRequest()->getBaseUrl(), $adminContext->getRequest()->getPathInfo(), http_build_query($routeParametersForReferrer));
  356.         }
  358.         $this->includeReferrer = null;
  359.         $this->customPageReferrer = null;
  361.         $this->routeParameters = $currentRouteParameters;
  362.     }
  363. }