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

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 = [];
  90.             foreach ($adminGroup['items'] as $item) {
  91.                 // NEXT_MAJOR: Remove the '' check
  92.                 if (!isset($item['admin']) || '' === $item['admin']) {
  93.                     continue;
  94.                 }
  96.                 $admin = $this->getInstance($item['admin']);
  98.                 // NEXT_MAJOR: Keep the "if" part.
  99.                 // @phpstan-ignore-next-line
  100.                 if (method_exists($admin, 'showInDashboard')) {
  101.                     if (!$admin->showInDashboard()) {
  102.                         continue;
  103.                     }
  104.                 } else {
  105.                     @trigger_error(\sprintf(
  106.                         'Not implementing "%s::showInDashboard()" is deprecated since sonata-project/admin-bundle 4.7'
  107.                         .' and will fail in 5.0.',
  108.                         AdminInterface::class
  109.                     ), \E_USER_DEPRECATED);
  111.                     /**
  112.                      * @psalm-suppress DeprecatedMethod, DeprecatedConstant
  113.                      */
  114.                     if (!$admin->showIn(AbstractAdmin::CONTEXT_DASHBOARD)) {
  115.                         continue;
  116.                     }
  117.                 }
  119.                 $items[] = $admin;
  120.             }
  122.             if ([] !== $items) {
  123.                 $groups[$name] = ['items' => $items] + $adminGroup;
  124.             }
  125.         }
  127.         return $groups;
  128.     }
  130.     /**
  131.      * Return the admin related to the given $class.
  132.      *
  133.      * @throws AdminClassNotFoundException if there is no admin class for the class provided
  134.      * @throws TooManyAdminClassException  if there is multiple admin class for the class provided
  135.      *
  136.      * @phpstan-param class-string $class
  137.      * @phpstan-return AdminInterface<object>
  138.      */
  139.     public function getAdminByClass(string $class): AdminInterface
  140.     {
  141.         if (!$this->hasAdminByClass($class)) {
  142.             throw new AdminClassNotFoundException(\sprintf('Pool has no admin for the class %s.', $class));
  143.         }
  145.         if (isset($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY])) {
  146.             return $this->getInstance($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY]);
  147.         }
  149.         if (1 !== \count($this->adminClasses[$class])) {
  150.             throw new TooManyAdminClassException(\sprintf(
  151.                 'Unable to find a valid admin for the class: %s, there are too many registered: %s.'
  152.                 .' Please define a default one with the tag attribute `default: true` in your admin configuration.',
  153.                 $class,
  154.                 implode(', ', $this->adminClasses[$class])
  155.             ));
  156.         }
  158.         return $this->getInstance(reset($this->adminClasses[$class]));
  159.     }
  161.     /**
  162.      * @phpstan-param class-string $class
  163.      */
  164.     public function hasAdminByClass(string $class): bool
  165.     {
  166.         return isset($this->adminClasses[$class]) && \count($this->adminClasses[$class]) > 0;
  167.     }
  169.     /**
  170.      * Returns an admin class by its Admin code
  171.      * ie : sonata.news.admin.post|sonata.news.admin.comment => return the child class of post.
  172.      *
  173.      * @throws AdminCodeNotFoundException
  174.      *
  175.      * @return AdminInterface<object>
  176.      */
  177.     public function getAdminByAdminCode(string $adminCode): AdminInterface
  178.     {
  179.         $codes = explode('|', $adminCode);
  180.         $rootCode = trim(array_shift($codes));
  181.         $admin = $this->getInstance($rootCode);
  183.         foreach ($codes as $code) {
  184.             if (!\in_array($code, $this->adminServiceCodes, true)) {
  185.                 throw new AdminCodeNotFoundException(\sprintf(
  186.                     'Argument 1 passed to %s() must contain a valid admin reference, "%s" found at "%s".',
  187.                     __METHOD__,
  188.                     $code,
  189.                     $adminCode
  190.                 ));
  191.             }
  193.             if (!$admin->hasChild($code)) {
  194.                 throw new AdminCodeNotFoundException(\sprintf(
  195.                     'Argument 1 passed to %s() must contain a valid admin hierarchy,'
  196.                     .' "%s" is not a valid child for "%s"',
  197.                     __METHOD__,
  198.                     $code,
  199.                     $admin->getCode()
  200.                 ));
  201.             }
  203.             $admin = $admin->getChild($code);
  204.         }
  206.         return $admin;
  207.     }
  209.     /**
  210.      * Checks if an admin with a certain admin code exists.
  211.      */
  212.     public function hasAdminByAdminCode(string $adminCode): bool
  213.     {
  214.         try {
  215.             $this->getAdminByAdminCode($adminCode);
  216.         } catch (\InvalidArgumentException) {
  217.             return false;
  218.         }
  220.         return true;
  221.     }
  223.     /**
  224.      * @throws AdminClassNotFoundException if there is no admin for the field description target model
  225.      * @throws TooManyAdminClassException  if there is too many admin for the field description target model
  226.      * @throws AdminCodeNotFoundException  if the admin_code option is invalid
  227.      *
  228.      * @return AdminInterface<object>
  229.      */
  230.     public function getAdminByFieldDescription(FieldDescriptionInterface $fieldDescription): AdminInterface
  231.     {
  232.         $adminCode = $fieldDescription->getOption('admin_code');
  234.         if (\is_string($adminCode)) {
  235.             return $this->getAdminByAdminCode($adminCode);
  236.         }
  238.         $targetModel = $fieldDescription->getTargetModel();
  239.         if (null === $targetModel) {
  240.             throw new \InvalidArgumentException('The field description has no target model.');
  241.         }
  243.         return $this->getAdminByClass($targetModel);
  244.     }
  246.     /**
  247.      * Returns a new admin instance depends on the given code.
  248.      *
  249.      * @throws AdminCodeNotFoundException if the code is not found in admin pool
  250.      *
  251.      * @return AdminInterface<object>
  252.      */
  253.     public function getInstance(string $code): AdminInterface
  254.     {
  255.         if ('' === $code) {
  256.             throw new \InvalidArgumentException(
  257.                 'Admin code must contain a valid admin reference, empty string given.'
  258.             );
  259.         }
  261.         if (!\in_array($code, $this->adminServiceCodes, true)) {
  262.             $msg = \sprintf('Admin service "%s" not found in admin pool.', $code);
  263.             $shortest = -1;
  264.             $closest = null;
  265.             $alternatives = [];
  267.             foreach ($this->adminServiceCodes as $adminServiceCode) {
  268.                 $lev = levenshtein($code, $adminServiceCode);
  269.                 if ($lev <= $shortest || $shortest < 0) {
  270.                     $closest = $adminServiceCode;
  271.                     $shortest = $lev;
  272.                 }
  273.                 if ($lev <= \strlen($adminServiceCode) / 3 || str_contains($adminServiceCode, $code)) {
  274.                     $alternatives[$adminServiceCode] = $lev;
  275.                 }
  276.             }
  278.             if (null !== $closest) {
  279.                 asort($alternatives);
  280.                 unset($alternatives[$closest]);
  281.                 $msg = \sprintf(
  282.                     'Admin service "%s" not found in admin pool. Did you mean "%s" or one of those: [%s]?',
  283.                     $code,
  284.                     $closest,
  285.                     implode(', ', array_keys($alternatives))
  286.                 );
  287.             }
  289.             throw new AdminCodeNotFoundException($msg);
  290.         }
  292.         $admin = $this->container->get($code);
  294.         if (!$admin instanceof AdminInterface) {
  295.             throw new \InvalidArgumentException(\sprintf('Found service "%s" is not a valid admin service', $code));
  296.         }
  298.         return $admin;
  299.     }
  301.     /**
  302.      * @return array<string, array<string, mixed>>
  303.      *
  304.      * @phpstan-return array<string, Group>
  305.      */
  306.     public function getAdminGroups(): array
  307.     {
  308.         return $this->adminGroups;
  309.     }
  311.     /**
  312.      * @return string[]
  313.      */
  314.     public function getAdminServiceCodes(): array
  315.     {
  316.         return $this->adminServiceCodes;
  317.     }
  319.     /**
  320.      * NEXT_MAJOR: Remove this method.
  321.      *
  322.      * @deprecated since sonata-project/admin-bundle 4.20 will be removed in 5.0 use getAdminServiceCodes() instead.
  323.      *
  324.      * @return string[]
  325.      */
  326.     public function getAdminServiceIds(): array
  327.     {
  328.         return $this->adminServiceCodes;
  329.     }
  331.     /**
  332.      * @return array<string, string[]>
  333.      *
  334.      * @phpstan-return array<class-string, string[]>
  335.      */
  336.     public function getAdminClasses(): array
  337.     {
  338.         return $this->adminClasses;
  339.     }
  340. }