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

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.     private ContainerInterface $container;
  56.     /**
  57.      * @var string[]
  58.      */
  59.     private array $adminServiceCodes = [];
  61.     /**
  62.      * @var array<string, array<string, mixed>>
  63.      *
  64.      * @phpstan-var array<string, Group>
  65.      */
  66.     private array $adminGroups = [];
  68.     /**
  69.      * @var array<string, string[]>
  70.      *
  71.      * @phpstan-var array<class-string, string[]>
  72.      */
  73.     private array $adminClasses = [];
  75.     /**
  76.      * @param string[]                            $adminServices
  77.      * @param array<string, array<string, mixed>> $adminGroups
  78.      * @param array<class-string, string[]>       $adminClasses
  79.      *
  80.      * @phpstan-param array<string, Group> $adminGroups
  81.      */
  82.     public function __construct(
  83.         ContainerInterface $container,
  84.         array $adminServices = [],
  85.         array $adminGroups = [],
  86.         array $adminClasses = []
  87.     ) {
  88.         $this->container = $container;
  89.         $this->adminServiceCodes = $adminServices;
  90.         $this->adminGroups = $adminGroups;
  91.         $this->adminClasses = $adminClasses;
  92.     }
  94.     /**
  95.      * @phpstan-return array<string, array{
  96.      *  label: string,
  97.      *  translation_domain: string,
  98.      *  icon: string,
  99.      *  items: list<AdminInterface<object>>,
  100.      *  keep_open: bool,
  101.      *  on_top: bool,
  102.      *  provider?: string,
  103.      *  roles: list<string>
  104.      * }>
  105.      */
  106.     public function getDashboardGroups(): array
  107.     {
  108.         $groups = [];
  110.         foreach ($this->adminGroups as $name => $adminGroup) {
  111.             $items = array_values(array_filter(array_map(function (array $item): ?AdminInterface {
  112.                 // NEXT_MAJOR: Remove the '' check
  113.                 if (!isset($item['admin']) || '' === $item['admin']) {
  114.                     return null;
  115.                 }
  117.                 $admin = $this->getInstance($item['admin']);
  119.                 // NEXT_MAJOR: Keep the if part.
  120.                 // @phpstan-ignore-next-line
  121.                 if (method_exists($admin, 'showInDashboard')) {
  122.                     if (!$admin->showInDashboard()) {
  123.                         return null;
  124.                     }
  125.                 } else {
  126.                     @trigger_error(sprintf(
  127.                         'Not implementing "%s::showInDashboard()" is deprecated since sonata-project/admin-bundle 4.7'
  128.                         .' and will fail in 5.0.',
  129.                         AdminInterface::class
  130.                     ), \E_USER_DEPRECATED);
  132.                     if (!$admin->showIn(AbstractAdmin::CONTEXT_DASHBOARD)) {
  133.                         return null;
  134.                     }
  135.                 }
  137.                 return $admin;
  138.             }, $adminGroup['items'])));
  140.             if ([] !== $items) {
  141.                 $groups[$name] = ['items' => $items] + $adminGroup;
  142.             }
  143.         }
  145.         return $groups;
  146.     }
  148.     /**
  149.      * Return the admin related to the given $class.
  150.      *
  151.      * @throws AdminClassNotFoundException if there is no admin class for the class provided
  152.      * @throws TooManyAdminClassException  if there is multiple admin class for the class provided
  153.      *
  154.      * @phpstan-param class-string $class
  155.      * @phpstan-return AdminInterface<object>
  156.      */
  157.     public function getAdminByClass(string $class): AdminInterface
  158.     {
  159.         if (!$this->hasAdminByClass($class)) {
  160.             throw new AdminClassNotFoundException(sprintf('Pool has no admin for the class %s.', $class));
  161.         }
  163.         if (isset($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY])) {
  164.             return $this->getInstance($this->adminClasses[$class][self::DEFAULT_ADMIN_KEY]);
  165.         }
  167.         if (1 !== \count($this->adminClasses[$class])) {
  168.             throw new TooManyAdminClassException(sprintf(
  169.                 'Unable to find a valid admin for the class: %s, there are too many registered: %s.'
  170.                 .' Please define a default one with the tag attribute `default: true` in your admin configuration.',
  171.                 $class,
  172.                 implode(', ', $this->adminClasses[$class])
  173.             ));
  174.         }
  176.         return $this->getInstance(reset($this->adminClasses[$class]));
  177.     }
  179.     /**
  180.      * @phpstan-param class-string $class
  181.      */
  182.     public function hasAdminByClass(string $class): bool
  183.     {
  184.         return isset($this->adminClasses[$class]) && \count($this->adminClasses[$class]) > 0;
  185.     }
  187.     /**
  188.      * Returns an admin class by its Admin code
  189.      * ie : sonata.news.admin.post|sonata.news.admin.comment => return the child class of post.
  190.      *
  191.      * @throws AdminCodeNotFoundException
  192.      *
  193.      * @return AdminInterface<object>
  194.      */
  195.     public function getAdminByAdminCode(string $adminCode): AdminInterface
  196.     {
  197.         $codes = explode('|', $adminCode);
  198.         $rootCode = trim(array_shift($codes));
  199.         $admin = $this->getInstance($rootCode);
  201.         foreach ($codes as $code) {
  202.             if (!\in_array($code, $this->adminServiceCodes, true)) {
  203.                 throw new AdminCodeNotFoundException(sprintf(
  204.                     'Argument 1 passed to %s() must contain a valid admin reference, "%s" found at "%s".',
  205.                     __METHOD__,
  206.                     $code,
  207.                     $adminCode
  208.                 ));
  209.             }
  211.             if (!$admin->hasChild($code)) {
  212.                 throw new AdminCodeNotFoundException(sprintf(
  213.                     'Argument 1 passed to %s() must contain a valid admin hierarchy,'
  214.                     .' "%s" is not a valid child for "%s"',
  215.                     __METHOD__,
  216.                     $code,
  217.                     $admin->getCode()
  218.                 ));
  219.             }
  221.             $admin = $admin->getChild($code);
  222.         }
  224.         return $admin;
  225.     }
  227.     /**
  228.      * Checks if an admin with a certain admin code exists.
  229.      */
  230.     public function hasAdminByAdminCode(string $adminCode): bool
  231.     {
  232.         try {
  233.             $this->getAdminByAdminCode($adminCode);
  234.         } catch (\InvalidArgumentException $e) {
  235.             return false;
  236.         }
  238.         return true;
  239.     }
  241.     /**
  242.      * @throws AdminClassNotFoundException if there is no admin for the field description target model
  243.      * @throws TooManyAdminClassException  if there is too many admin for the field description target model
  244.      * @throws AdminCodeNotFoundException  if the admin_code option is invalid
  245.      *
  246.      * @return AdminInterface<object>
  247.      */
  248.     public function getAdminByFieldDescription(FieldDescriptionInterface $fieldDescription): AdminInterface
  249.     {
  250.         $adminCode = $fieldDescription->getOption('admin_code');
  252.         if (\is_string($adminCode)) {
  253.             return $this->getAdminByAdminCode($adminCode);
  254.         }
  256.         $targetModel = $fieldDescription->getTargetModel();
  257.         if (null === $targetModel) {
  258.             throw new \InvalidArgumentException('The field description has no target model.');
  259.         }
  261.         return $this->getAdminByClass($targetModel);
  262.     }
  264.     /**
  265.      * Returns a new admin instance depends on the given code.
  266.      *
  267.      * @throws AdminCodeNotFoundException if the code is not found in admin pool
  268.      *
  269.      * @return AdminInterface<object>
  270.      */
  271.     public function getInstance(string $code): AdminInterface
  272.     {
  273.         if ('' === $code) {
  274.             throw new \InvalidArgumentException(
  275.                 'Admin code must contain a valid admin reference, empty string given.'
  276.             );
  277.         }
  279.         if (!\in_array($code, $this->adminServiceCodes, true)) {
  280.             $msg = sprintf('Admin service "%s" not found in admin pool.', $code);
  281.             $shortest = -1;
  282.             $closest = null;
  283.             $alternatives = [];
  285.             foreach ($this->adminServiceCodes as $adminServiceCode) {
  286.                 $lev = levenshtein($code, $adminServiceCode);
  287.                 if ($lev <= $shortest || $shortest < 0) {
  288.                     $closest = $adminServiceCode;
  289.                     $shortest = $lev;
  290.                 }
  291.                 if ($lev <= \strlen($adminServiceCode) / 3 || false !== strpos($adminServiceCode, $code)) {
  292.                     $alternatives[$adminServiceCode] = $lev;
  293.                 }
  294.             }
  296.             if (null !== $closest) {
  297.                 asort($alternatives);
  298.                 unset($alternatives[$closest]);
  299.                 $msg = sprintf(
  300.                     'Admin service "%s" not found in admin pool. Did you mean "%s" or one of those: [%s]?',
  301.                     $code,
  302.                     $closest,
  303.                     implode(', ', array_keys($alternatives))
  304.                 );
  305.             }
  307.             throw new AdminCodeNotFoundException($msg);
  308.         }
  310.         $admin = $this->container->get($code);
  312.         if (!$admin instanceof AdminInterface) {
  313.             throw new \InvalidArgumentException(sprintf('Found service "%s" is not a valid admin service', $code));
  314.         }
  316.         return $admin;
  317.     }
  319.     /**
  320.      * @return array<string, array<string, mixed>>
  321.      *
  322.      * @phpstan-return array<string, Group>
  323.      */
  324.     public function getAdminGroups(): array
  325.     {
  326.         return $this->adminGroups;
  327.     }
  329.     /**
  330.      * @return string[]
  331.      */
  332.     public function getAdminServiceCodes(): array
  333.     {
  334.         return $this->adminServiceCodes;
  335.     }
  337.     /**
  338.      * NEXT_MAJOR: Remove this method.
  339.      *
  340.      * @deprecated since sonata-project/admin-bundle 4.20 will be removed in 5.0 use getAdminServiceCodes() instead.
  341.      *
  342.      * @return string[]
  343.      */
  344.     public function getAdminServiceIds(): array
  345.     {
  346.         return $this->adminServiceCodes;
  347.     }
  349.     /**
  350.      * @return array<string, string[]>
  351.      *
  352.      * @phpstan-return array<class-string, string[]>
  353.      */
  354.     public function getAdminClasses(): array
  355.     {
  356.         return $this->adminClasses;
  357.     }
  358. }