vendor/sonata-project/admin-bundle/src/Admin/Pool.php line 249

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\Admin;
  16. use Psr\Container\ContainerInterface;
  17. use Sonata\AdminBundle\Exception\AdminClassNotFoundException;
  18. use Sonata\AdminBundle\Exception\AdminCodeNotFoundException;
  19. use Sonata\AdminBundle\Exception\TooManyAdminClassException;
  20. use Sonata\AdminBundle\FieldDescription\FieldDescriptionInterface;
  22. /**
  23.  * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
  24.  *
  25.  * @phpstan-type Item = array{
  26.  *     label: string,
  27.  *     roles: list<string>,
  28.  *     route: string,
  29.  *     route_absolute: bool,
  30.  *     route_params: array<string, string>
  31.  * }|array{
  32.  *     admin: string,
  33.  *     roles: list<string>,
  34.  *     route_absolute: bool,
  35.  *     route_params: array<string, string>
  36.  * }
  37.  * NEXT_MAJOR: Remove the label_catalogue key.
  38.  * @phpstan-type Group = array{
  39.  *     label: string,
  40.  *     translation_domain: string,
  41.  *     label_catalogue?: string,
  42.  *     icon: string,
  43.  *     items: list<Item>,
  44.  *     keep_open: bool,
  45.  *     on_top: bool,
  46.  *     provider?: string,
  47.  *     roles: list<string>
  48.  * }
  49.  */
  50. final class Pool
  51. {
  52.     public const DEFAULT_ADMIN_KEY = 'default';
  54.     /**
  55.      * @param string[]                            $adminServiceCodes
  56.      * @param array<string, array<string, mixed>> $adminGroups
  57.      * @param array<class-string, string[]>       $adminClasses
  58.      *
  59.      * @phpstan-param array<string, Group> $adminGroups
  60.      */
  61.     public function __construct(
  62.         private ContainerInterface $container,
  63.         private array $adminServiceCodes = [],
  64.         private array $adminGroups = [],
  65.         private array $adminClasses = []
  66.     ) {
  67.     }
  69.     /**
  70.      * NEXT_MAJOR: Remove the label_catalogue key.
  71.      *
  72.      * @phpstan-return array<string, array{
  73.      *  label: string,
  74.      *  label_catalogue?: string,
  75.      *  translation_domain: string,
  76.      *  icon: string,
  77.      *  items: list<AdminInterface<object>>,
  78.      *  keep_open: bool,
  79.      *  on_top: bool,
  80.      *  provider?: string,
  81.      *  roles: list<string>
  82.      * }>
  83.      */
  84.     public function getDashboardGroups(): array
  85.     {
  86.         $groups = [];
  88.         foreach ($this->adminGroups as $name => $adminGroup) {
  89.             $items = array_values(array_filter(array_map(function (array $item): ?AdminInterface {
  90.                 // NEXT_MAJOR: Remove the '' check
  91.                 if (!isset($item['admin']) || '' === $item['admin']) {
  92.                     return null;
  93.                 }
  95.                 $admin = $this->getInstance($item['admin']);
  97.                 // NEXT_MAJOR: Keep the if part.
  98.                 // @phpstan-ignore-next-line
  99.                 if (method_exists($admin, 'showInDashboard')) {
  100.                     if (!$admin->showInDashboard()) {
  101.                         return null;
  102.                     }
  103.                 } else {
  104.                     @trigger_error(sprintf(
  105.                         'Not implementing "%s::showInDashboard()" is deprecated since sonata-project/admin-bundle 4.7'
  106.                         .' and will fail in 5.0.',
  107.                         AdminInterface::class
  108.                     ), \E_USER_DEPRECATED);
  110.                     if (!$admin->showIn(AbstractAdmin::CONTEXT_DASHBOARD)) {
  111.                         return null;
  112.                     }
  113.                 }
  115.                 return $admin;
  116.             }, $adminGroup['items'])));
  118.             if ([] !== $items) {
  119.                 $groups[$name] = ['items' => $items] + $adminGroup;
  120.             }
  121.         }
  123.         return $groups;
  124.     }
  126.     /**
  127.      * Return the admin related to the given $class.
  128.      *
  129.      * @throws AdminClassNotFoundException if there is no admin class for the class provided
  130.      * @throws TooManyAdminClassException  if there is multiple admin class for the class provided
  131.      *
  132.      * @phpstan-param class-string $class
  133.      * @phpstan-return AdminInterface<object>
  134.      */
  135.     public function getAdminByClass(string $class): AdminInterface
  136.     {
  137.         if (!$this->hasAdminByClass($class)) {
  138.             throw new AdminClassNotFoundException(sprintf('Pool has no admin for the class %s.', $class));
  139.         }
  141.         if (isset($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY])) {
  142.             return $this->getInstance($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY]);
  143.         }
  145.         if (1 !== \count($this->adminClasses[$class])) {
  146.             throw new TooManyAdminClassException(sprintf(
  147.                 'Unable to find a valid admin for the class: %s, there are too many registered: %s.'
  148.                 .' Please define a default one with the tag attribute `default: true` in your admin configuration.',
  149.                 $class,
  150.                 implode(', ', $this->adminClasses[$class])
  151.             ));
  152.         }
  154.         return $this->getInstance(reset($this->adminClasses[$class]));
  155.     }
  157.     /**
  158.      * @phpstan-param class-string $class
  159.      */
  160.     public function hasAdminByClass(string $class): bool
  161.     {
  162.         return isset($this->adminClasses[$class]) && \count($this->adminClasses[$class]) > 0;
  163.     }
  165.     /**
  166.      * Returns an admin class by its Admin code
  167.      * ie : sonata.news.admin.post|sonata.news.admin.comment => return the child class of post.
  168.      *
  169.      * @throws AdminCodeNotFoundException
  170.      *
  171.      * @return AdminInterface<object>
  172.      */
  173.     public function getAdminByAdminCode(string $adminCode): AdminInterface
  174.     {
  175.         $codes = explode('|', $adminCode);
  176.         $rootCode = trim(array_shift($codes));
  177.         $admin = $this->getInstance($rootCode);
  179.         foreach ($codes as $code) {
  180.             if (!\in_array($code, $this->adminServiceCodes, true)) {
  181.                 throw new AdminCodeNotFoundException(sprintf(
  182.                     'Argument 1 passed to %s() must contain a valid admin reference, "%s" found at "%s".',
  183.                     __METHOD__,
  184.                     $code,
  185.                     $adminCode
  186.                 ));
  187.             }
  189.             if (!$admin->hasChild($code)) {
  190.                 throw new AdminCodeNotFoundException(sprintf(
  191.                     'Argument 1 passed to %s() must contain a valid admin hierarchy,'
  192.                     .' "%s" is not a valid child for "%s"',
  193.                     __METHOD__,
  194.                     $code,
  195.                     $admin->getCode()
  196.                 ));
  197.             }
  199.             $admin = $admin->getChild($code);
  200.         }
  202.         return $admin;
  203.     }
  205.     /**
  206.      * Checks if an admin with a certain admin code exists.
  207.      */
  208.     public function hasAdminByAdminCode(string $adminCode): bool
  209.     {
  210.         try {
  211.             $this->getAdminByAdminCode($adminCode);
  212.         } catch (\InvalidArgumentException) {
  213.             return false;
  214.         }
  216.         return true;
  217.     }
  219.     /**
  220.      * @throws AdminClassNotFoundException if there is no admin for the field description target model
  221.      * @throws TooManyAdminClassException  if there is too many admin for the field description target model
  222.      * @throws AdminCodeNotFoundException  if the admin_code option is invalid
  223.      *
  224.      * @return AdminInterface<object>
  225.      */
  226.     public function getAdminByFieldDescription(FieldDescriptionInterface $fieldDescription): AdminInterface
  227.     {
  228.         $adminCode = $fieldDescription->getOption('admin_code');
  230.         if (\is_string($adminCode)) {
  231.             return $this->getAdminByAdminCode($adminCode);
  232.         }
  234.         $targetModel = $fieldDescription->getTargetModel();
  235.         if (null === $targetModel) {
  236.             throw new \InvalidArgumentException('The field description has no target model.');
  237.         }
  239.         return $this->getAdminByClass($targetModel);
  240.     }
  242.     /**
  243.      * Returns a new admin instance depends on the given code.
  244.      *
  245.      * @throws AdminCodeNotFoundException if the code is not found in admin pool
  246.      *
  247.      * @return AdminInterface<object>
  248.      */
  249.     public function getInstance(string $code): AdminInterface
  250.     {
  251.         if ('' === $code) {
  252.             throw new \InvalidArgumentException(
  253.                 'Admin code must contain a valid admin reference, empty string given.'
  254.             );
  255.         }
  257.         if (!\in_array($code, $this->adminServiceCodes, true)) {
  258.             $msg = sprintf('Admin service "%s" not found in admin pool.', $code);
  259.             $shortest = -1;
  260.             $closest = null;
  261.             $alternatives = [];
  263.             foreach ($this->adminServiceCodes as $adminServiceCode) {
  264.                 $lev = levenshtein($code, $adminServiceCode);
  265.                 if ($lev <= $shortest || $shortest < 0) {
  266.                     $closest = $adminServiceCode;
  267.                     $shortest = $lev;
  268.                 }
  269.                 if ($lev <= \strlen($adminServiceCode) / 3 || str_contains($adminServiceCode, $code)) {
  270.                     $alternatives[$adminServiceCode] = $lev;
  271.                 }
  272.             }
  274.             if (null !== $closest) {
  275.                 asort($alternatives);
  276.                 unset($alternatives[$closest]);
  277.                 $msg = sprintf(
  278.                     'Admin service "%s" not found in admin pool. Did you mean "%s" or one of those: [%s]?',
  279.                     $code,
  280.                     $closest,
  281.                     implode(', ', array_keys($alternatives))
  282.                 );
  283.             }
  285.             throw new AdminCodeNotFoundException($msg);
  286.         }
  288.         $admin = $this->container->get($code);
  290.         if (!$admin instanceof AdminInterface) {
  291.             throw new \InvalidArgumentException(sprintf('Found service "%s" is not a valid admin service', $code));
  292.         }
  294.         return $admin;
  295.     }
  297.     /**
  298.      * @return array<string, array<string, mixed>>
  299.      *
  300.      * @phpstan-return array<string, Group>
  301.      */
  302.     public function getAdminGroups(): array
  303.     {
  304.         return $this->adminGroups;
  305.     }
  307.     /**
  308.      * @return string[]
  309.      */
  310.     public function getAdminServiceCodes(): array
  311.     {
  312.         return $this->adminServiceCodes;
  313.     }
  315.     /**
  316.      * NEXT_MAJOR: Remove this method.
  317.      *
  318.      * @deprecated since sonata-project/admin-bundle 4.20 will be removed in 5.0 use getAdminServiceCodes() instead.
  319.      *
  320.      * @return string[]
  321.      */
  322.     public function getAdminServiceIds(): array
  323.     {
  324.         return $this->adminServiceCodes;
  325.     }
  327.     /**
  328.      * @return array<string, string[]>
  329.      *
  330.      * @phpstan-return array<class-string, string[]>
  331.      */
  332.     public function getAdminClasses(): array
  333.     {
  334.         return $this->adminClasses;
  335.     }
  336. }