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

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