vendor/sonata-project/admin-bundle/src/Menu/Provider/GroupMenuProvider.php line 53

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\AdminBundle\Menu\Provider;
  16. use Knp\Menu\FactoryInterface;
  17. use Knp\Menu\ItemInterface;
  18. use Knp\Menu\Provider\MenuProviderInterface;
  19. use Sonata\AdminBundle\Admin\Pool;
  20. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  21. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  23. /**
  24.  * Menu provider based on group options.
  25.  *
  26.  * @author Alexandru Furculita <alex@furculita.net>
  27.  *
  28.  * @phpstan-import-type Item from Pool
  29.  * @phpstan-import-type Group from Pool
  30.  */
  31. final class GroupMenuProvider implements MenuProviderInterface
  32. {
  33.     private FactoryInterface $menuFactory;
  35.     private Pool $pool;
  37.     private AuthorizationCheckerInterface $checker;
  39.     public function __construct(FactoryInterface $menuFactory, Pool $pool, AuthorizationCheckerInterface $checker)
  40.     {
  41.         $this->menuFactory = $menuFactory;
  42.         $this->pool = $pool;
  43.         $this->checker = $checker;
  44.     }
  46.     /**
  47.      * Retrieves the menu based on the group options.
  48.      *
  49.      * @param array<string, mixed> $options
  50.      *
  51.      * @throws \InvalidArgumentException if the menu does not exist
  52.      */
  53.     public function get(string $name, array $options = []): ItemInterface
  54.     {
  55.         if (!isset($options['name']) || !\is_string($options['name'])) {
  56.             throw new \InvalidArgumentException('The option "name" is required.');
  57.         }
  58.         $menuItem = $this->menuFactory->createItem($options['name']);
  60.         if (!isset($options['group'])) {
  61.             throw new \InvalidArgumentException('The option "group" is required.');
  62.         }
  63.         /** @phpstan-var Group $group */
  64.         $group = $options['group'];
  66.         if (false === $group['on_top']) {
  67.             foreach ($group['items'] as $item) {
  68.                 if ($this->canGenerateMenuItem($item, $group)) {
  69.                     $menuItem->addChild($this->generateMenuItem($item, $group));
  70.                 }
  71.             }
  73.             if (false === $menuItem->hasChildren()) {
  74.                 $menuItem->setDisplay(false);
  75.             } elseif ($group['keep_open']) {
  76.                 $menuItem->setAttribute('class', 'keep-open');
  77.                 $menuItem->setExtra('keep_open', $group['keep_open']);
  78.             }
  79.         } elseif (
  80.             1 === \count($group['items'])
  81.             && $this->canGenerateMenuItem($group['items'][0], $group)
  82.         ) {
  83.             $menuItem = $this->generateMenuItem($group['items'][0], $group);
  84.             $menuItem->setExtra('on_top', $group['on_top']);
  85.         } else {
  86.             $menuItem->setDisplay(false);
  87.         }
  89.         $menuItem->setLabel($group['label']);
  91.         return $menuItem;
  92.     }
  94.     /**
  95.      * Checks whether a menu exists in this provider.
  96.      *
  97.      * @param mixed[] $options
  98.      */
  99.     public function has(string $name, array $options = []): bool
  100.     {
  101.         return 'sonata_group_menu' === $name;
  102.     }
  104.     /**
  105.      * @phpstan-param Item $item
  106.      * @phpstan-param Group $group
  107.      */
  108.     private function canGenerateMenuItem(array $item, array $group): bool
  109.     {
  110.         // NEXT_MAJOR: Remove the '' check
  111.         if (isset($item['admin']) && '' !== $item['admin']) {
  112.             $admin = $this->pool->getInstance($item['admin']);
  114.             // skip menu item if no `list` url is available or user doesn't have the LIST access rights
  115.             return $admin->hasRoute('list') && $admin->hasAccess('list');
  116.         }
  118.         // Making the checker behave affirmatively even if it's globally unanimous
  119.         // Still must be granted unanimously to group and item
  121.         $isItemGranted = true;
  122.         if (isset($item['roles']) && [] !== $item['roles']) {
  123.             $isItemGranted = false;
  124.             foreach ($item['roles'] as $role) {
  125.                 if ($this->checker->isGranted($role)) {
  126.                     $isItemGranted = true;
  127.                     break;
  128.                 }
  129.             }
  130.         }
  132.         $isGroupGranted = true;
  133.         if (isset($group['roles']) && [] !== $group['roles']) {
  134.             $isGroupGranted = false;
  135.             foreach ($group['roles'] as $role) {
  136.                 if ($this->checker->isGranted($role)) {
  137.                     $isGroupGranted = true;
  138.                     break;
  139.                 }
  140.             }
  141.         }
  143.         return $isItemGranted && $isGroupGranted;
  144.     }
  146.     /**
  147.      * @phpstan-param Item $item
  148.      * @phpstan-param Group $group
  149.      */
  150.     private function generateMenuItem(array $item, array $group): ItemInterface
  151.     {
  152.         // NEXT_MAJOR: Remove the '' check
  153.         if (isset($item['admin']) && '' !== $item['admin']) {
  154.             $admin = $this->pool->getInstance($item['admin']);
  156.             $options = $admin->generateMenuUrl(
  157.                 'list',
  158.                 $item['route_params'],
  159.                 $item['route_absolute'] ? UrlGeneratorInterface::ABSOLUTE_URL : UrlGeneratorInterface::ABSOLUTE_PATH
  160.             );
  161.             $options['extras'] = [
  162.                 'label_catalogue' => $admin->getTranslationDomain(), // NEXT_MAJOR: Remove this line.
  163.                 'translation_domain' => $admin->getTranslationDomain(),
  164.                 'admin' => $admin,
  165.             ];
  167.             return $this->menuFactory->createItem($admin->getLabel() ?? '', $options);
  168.         }
  170.         \assert(isset($item['label']));
  172.         return $this->menuFactory->createItem($item['label'], [
  173.             'route' => $item['route'],
  174.             'routeParameters' => $item['route_params'],
  175.             'routeAbsolute' => $item['route_absolute'],
  176.             'extras' => [
  177.                 'translation_domain' => $group['translation_domain'],
  178.                 'label_catalogue' => $group['label_catalogue'] ?? '', // NEXT_MAJOR: Remove this line.
  179.             ],
  180.         ]);
  181.     }
  182. }