vendor/sonata-project/admin-bundle/src/Admin/AbstractAdmin.php line 2545

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 Knp\Menu\ItemInterface;
  17. use Sonata\AdminBundle\BCLayer\BCHelper;
  18. use Sonata\AdminBundle\Datagrid\DatagridInterface;
  19. use Sonata\AdminBundle\Datagrid\DatagridMapper;
  20. use Sonata\AdminBundle\Datagrid\ListMapper;
  21. use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
  22. use Sonata\AdminBundle\DependencyInjection\Admin\AbstractTaggedAdmin;
  23. use Sonata\AdminBundle\Exception\AdminClassNotFoundException;
  24. use Sonata\AdminBundle\FieldDescription\FieldDescriptionCollection;
  25. use Sonata\AdminBundle\FieldDescription\FieldDescriptionInterface;
  26. use Sonata\AdminBundle\Form\FormMapper;
  27. use Sonata\AdminBundle\Form\Type\ModelHiddenType;
  28. use Sonata\AdminBundle\Manipulator\ObjectManipulator;
  29. use Sonata\AdminBundle\Model\ProxyResolverInterface;
  30. use Sonata\AdminBundle\Object\Metadata;
  31. use Sonata\AdminBundle\Object\MetadataInterface;
  32. use Sonata\AdminBundle\Route\RouteCollection;
  33. use Sonata\AdminBundle\Route\RouteCollectionInterface;
  34. use Sonata\AdminBundle\Security\Acl\Permission\AdminPermissionMap;
  35. use Sonata\AdminBundle\Security\Handler\AclSecurityHandlerInterface;
  36. use Sonata\AdminBundle\Show\ShowMapper;
  37. use Sonata\AdminBundle\Util\Instantiator;
  38. use Sonata\AdminBundle\Util\ParametersManipulator;
  39. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  40. use Symfony\Component\Form\FormBuilderInterface;
  41. use Symfony\Component\Form\FormEvent;
  42. use Symfony\Component\Form\FormEvents;
  43. use Symfony\Component\Form\FormInterface;
  44. use Symfony\Component\HttpFoundation\InputBag;
  45. use Symfony\Component\HttpFoundation\ParameterBag;
  46. use Symfony\Component\HttpFoundation\Request;
  47. use Symfony\Component\PropertyAccess\Exception\AccessException;
  48. use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
  49. use Symfony\Component\PropertyAccess\PropertyAccess;
  50. use Symfony\Component\Routing\Generator\UrlGeneratorInterface as RoutingUrlGeneratorInterface;
  51. use Symfony\Component\Security\Acl\Model\DomainObjectInterface;
  52. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  54. /**
  55.  * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
  56.  *
  57.  * @phpstan-template T of object
  58.  * @phpstan-extends AbstractTaggedAdmin<T>
  59.  * @phpstan-implements AdminInterface<T>
  60.  */
  61. abstract class AbstractAdmin extends AbstractTaggedAdmin implements AdminInterface, DomainObjectInterface, AdminTreeInterface
  62. {
  63.     // NEXT_MAJOR: Remove the CONTEXT constants.
  64.     /** @deprecated */
  65.     public const CONTEXT_MENU = 'menu';
  66.     /** @deprecated */
  67.     public const CONTEXT_DASHBOARD = 'dashboard';
  69.     public const CLASS_REGEX =
  70.         '@
  71.         (?:([A-Za-z0-9]*)\\\)?        # vendor name / app name
  72.         (Bundle\\\)?                  # optional bundle directory
  73.         ([A-Za-z0-9]+?)(?:Bundle)?\\\ # bundle name, with optional suffix
  74.         (
  75.             Entity|Document|Model|PHPCR|CouchDocument|Phpcr|
  76.             Doctrine\\\Orm|Doctrine\\\Phpcr|Doctrine\\\MongoDB|Doctrine\\\CouchDB
  77.         )\\\(.*)@x';
  79.     private const ACTION_TREE = 1;
  80.     private const ACTION_SHOW = 2;
  81.     private const ACTION_EDIT = 4;
  82.     private const ACTION_DELETE = 8;
  83.     private const ACTION_ACL = 16;
  84.     private const ACTION_HISTORY = 32;
  85.     private const ACTION_LIST = 64;
  86.     private const ACTION_BATCH = 128;
  87.     private const INTERNAL_ACTIONS = [
  88.         'tree' => self::ACTION_TREE,
  89.         'show' => self::ACTION_SHOW,
  90.         'edit' => self::ACTION_EDIT,
  91.         'delete' => self::ACTION_DELETE,
  92.         'acl' => self::ACTION_ACL,
  93.         'history' => self::ACTION_HISTORY,
  94.         'list' => self::ACTION_LIST,
  95.         'batch' => self::ACTION_BATCH,
  96.     ];
  97.     private const MASK_OF_ACTION_CREATE = self::ACTION_TREE | self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_LIST | self::ACTION_BATCH;
  98.     private const MASK_OF_ACTION_SHOW = self::ACTION_EDIT | self::ACTION_HISTORY | self::ACTION_ACL;
  99.     private const MASK_OF_ACTION_EDIT = self::ACTION_SHOW | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_HISTORY;
  100.     private const MASK_OF_ACTION_HISTORY = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_ACL;
  101.     private const MASK_OF_ACTION_ACL = self::ACTION_EDIT | self::ACTION_HISTORY;
  102.     private const MASK_OF_ACTION_LIST = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_BATCH;
  103.     private const MASK_OF_ACTIONS_USING_OBJECT = self::MASK_OF_ACTION_SHOW | self::MASK_OF_ACTION_EDIT | self::MASK_OF_ACTION_HISTORY | self::MASK_OF_ACTION_ACL;
  105.     private const DEFAULT_LIST_PER_PAGE_RESULTS = 25;
  106.     private const DEFAULT_LIST_PER_PAGE_OPTIONS = [10, 25, 50, 100, 250];
  108.     /**
  109.      * @deprecated since sonata-project/admin-bundle 4.15, will be removed in 5.0.
  110.      *
  111.      * The base route name used to generate the routing information.
  112.      *
  113.      * @var string|null
  114.      */
  115.     protected $baseRouteName;
  117.     /**
  118.      * @deprecated since sonata-project/admin-bundle 4.15, will be removed in 5.0.
  119.      *
  120.      * The base route pattern used to generate the routing information.
  121.      *
  122.      * @var string|null
  123.      */
  124.     protected $baseRoutePattern;
  126.     /**
  127.      * The label class name  (used in the title/breadcrumb ...).
  128.      *
  129.      * @var string|null
  130.      */
  131.     protected $classnameLabel;
  133.     /**
  134.      * Setting to true will enable preview mode for
  135.      * the entity and show a preview button in the
  136.      * edit/create forms.
  137.      *
  138.      * @var bool
  139.      */
  140.     protected $supportsPreviewMode = false;
  142.     /**
  143.      * The list FieldDescription constructed from the configureListField method.
  144.      *
  145.      * @var array<string, FieldDescriptionInterface>
  146.      */
  147.     private array $listFieldDescriptions = [];
  149.     /**
  150.      * The show FieldDescription constructed from the configureShowFields method.
  151.      *
  152.      * @var FieldDescriptionInterface[]
  153.      */
  154.     private array $showFieldDescriptions = [];
  156.     /**
  157.      * The list FieldDescription constructed from the configureFormField method.
  158.      *
  159.      * @var FieldDescriptionInterface[]
  160.      */
  161.     private array $formFieldDescriptions = [];
  163.     /**
  164.      * The filter FieldDescription constructed from the configureFilterField method.
  165.      *
  166.      * @var FieldDescriptionInterface[]
  167.      */
  168.     private array $filterFieldDescriptions = [];
  170.     /**
  171.      * The maximum number of page numbers to display in the list.
  172.      */
  173.     private int $maxPageLinks = 25;
  175.     /**
  176.      * The translation domain to be used to translate messages.
  177.      */
  178.     private string $translationDomain = 'messages';
  180.     /**
  181.      * Array of routes related to this admin.
  182.      */
  183.     private ?RouteCollectionInterface $routes = null;
  185.     /**
  186.      * The subject only set in edit/update/create mode.
  187.      *
  188.      * @phpstan-var T|null
  189.      */
  190.     private ?object $subject = null;
  192.     /**
  193.      * Define a Collection of child admin, ie /admin/order/{id}/order-element/{childId}.
  194.      *
  195.      * @var array<string, AdminInterface<object>>
  196.      */
  197.     private array $children = [];
  199.     /**
  200.      * Reference the parent admin.
  201.      *
  202.      * @var AdminInterface<object>|null
  203.      */
  204.     private ?AdminInterface $parent = null;
  206.     /**
  207.      * Reference the parent FieldDescription related to this admin
  208.      * only set for FieldDescription which is associated to an Sub Admin instance.
  209.      */
  210.     private ?FieldDescriptionInterface $parentFieldDescription = null;
  212.     /**
  213.      * If true then the current admin is part of the nested admin set (from the url).
  214.      */
  215.     private bool $currentChild = false;
  217.     /**
  218.      * The uniqId is used to avoid clashing with 2 admin related to the code
  219.      * ie: a Block linked to a Block.
  220.      */
  221.     private ?string $uniqId = null;
  223.     /**
  224.      * The current request object.
  225.      */
  226.     private ?Request $request = null;
  228.     /**
  229.      * @phpstan-var DatagridInterface<ProxyQueryInterface<T>>|null
  230.      */
  231.     private ?DatagridInterface $datagrid = null;
  233.     private ?ItemInterface $menu = null;
  235.     /**
  236.      * @var string[]
  237.      */
  238.     private array $formTheme = [];
  240.     /**
  241.      * @var string[]
  242.      */
  243.     private array $filterTheme = [];
  245.     /**
  246.      * @var AdminExtensionInterface[]
  247.      *
  248.      * @phpstan-var array<AdminExtensionInterface<T>>
  249.      */
  250.     private array $extensions = [];
  252.     /**
  253.      * @var array<string, bool>
  254.      */
  255.     private array $cacheIsGranted = [];
  257.     /**
  258.      * @var array<string, string|null>
  259.      */
  260.     private array $parentAssociationMapping = [];
  262.     /**
  263.      * The subclasses supported by the admin class.
  264.      *
  265.      * @var string[]
  266.      *
  267.      * @phpstan-var array<string, class-string<T>>
  268.      */
  269.     private array $subClasses = [];
  271.     /**
  272.      * The list collection.
  273.      *
  274.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  275.      */
  276.     private ?FieldDescriptionCollection $list = null;
  278.     /**
  279.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  280.      */
  281.     private ?FieldDescriptionCollection $show = null;
  283.     private ?FormInterface $form = null;
  285.     /**
  286.      * The cached base route name.
  287.      */
  288.     private ?string $cachedBaseRouteName = null;
  290.     /**
  291.      * The cached base route pattern.
  292.      */
  293.     private ?string $cachedBaseRoutePattern = null;
  295.     /**
  296.      * The form group disposition.
  297.      *
  298.      * @var array<string, array<string, mixed>>
  299.      */
  300.     private array $formGroups = [];
  302.     /**
  303.      * The form tabs disposition.
  304.      *
  305.      * @var array<string, array<string, mixed>>
  306.      */
  307.     private array $formTabs = [];
  309.     /**
  310.      * The view group disposition.
  311.      *
  312.      * @var array<string, array<string, mixed>>
  313.      */
  314.     private array $showGroups = [];
  316.     /**
  317.      * The view tab disposition.
  318.      *
  319.      * @var array<string, array<string, mixed>>
  320.      */
  321.     private array $showTabs = [];
  323.     /**
  324.      * @var array<string, bool>
  325.      */
  326.     private array $loaded = [
  327.         'routes' => false,
  328.         'tab_menu' => false,
  329.         'show' => false,
  330.         'list' => false,
  331.         'form' => false,
  332.         'datagrid' => false,
  333.     ];
  335.     public function getExportFormats(): array
  336.     {
  337.         return [];
  338.     }
  340.     final public function getExportFields(): array
  341.     {
  342.         $fields = $this->configureExportFields();
  344.         foreach ($this->getExtensions() as $extension) {
  345.             $fields = $extension->configureExportFields($this, $fields);
  346.         }
  348.         return $fields;
  349.     }
  351.     final public function getDataSourceIterator(): \Iterator
  352.     {
  353.         $datagrid = $this->getDatagrid();
  354.         $datagrid->buildPager();
  356.         $fields = [];
  358.         foreach ($this->getExportFields() as $key => $field) {
  359.             if (!\is_string($key)) {
  360.                 $label = $this->getTranslationLabel($field, 'export', 'label');
  361.                 $key = $this->getTranslator()->trans($label, [], $this->getTranslationDomain());
  362.             }
  364.             $fields[$key] = $field;
  365.         }
  367.         $query = $datagrid->getQuery();
  369.         return $this->getDataSource()->createIterator($query, $fields);
  370.     }
  372.     final public function initialize(): void
  373.     {
  374.         if (null === $this->classnameLabel) {
  375.             $namespaceSeparatorPos = strrpos($this->getClass(), '\\');
  376.             $this->classnameLabel = false !== $namespaceSeparatorPos
  377.                 ? substr($this->getClass(), $namespaceSeparatorPos + 1)
  378.                 : $this->getClass();
  379.         }
  381.         $this->configure();
  383.         foreach ($this->getExtensions() as $extension) {
  384.             $extension->configure($this);
  385.         }
  386.     }
  388.     final public function update(object $object): object
  389.     {
  390.         $this->preUpdate($object);
  391.         foreach ($this->getExtensions() as $extension) {
  392.             $extension->preUpdate($this, $object);
  393.         }
  395.         $this->getModelManager()->update($object);
  397.         $this->postUpdate($object);
  398.         foreach ($this->getExtensions() as $extension) {
  399.             $extension->postUpdate($this, $object);
  400.         }
  402.         return $object;
  403.     }
  405.     final public function create(object $object): object
  406.     {
  407.         $this->prePersist($object);
  408.         foreach ($this->getExtensions() as $extension) {
  409.             $extension->prePersist($this, $object);
  410.         }
  412.         $this->getModelManager()->create($object);
  414.         $this->postPersist($object);
  415.         foreach ($this->getExtensions() as $extension) {
  416.             $extension->postPersist($this, $object);
  417.         }
  419.         $this->createObjectSecurity($object);
  421.         return $object;
  422.     }
  424.     final public function delete(object $object): void
  425.     {
  426.         $this->preRemove($object);
  427.         foreach ($this->getExtensions() as $extension) {
  428.             $extension->preRemove($this, $object);
  429.         }
  431.         $this->getSecurityHandler()->deleteObjectSecurity($this, $object);
  432.         $this->getModelManager()->delete($object);
  434.         $this->postRemove($object);
  435.         foreach ($this->getExtensions() as $extension) {
  436.             $extension->postRemove($this, $object);
  437.         }
  438.     }
  440.     public function preBatchAction(string $actionName, ProxyQueryInterface $query, array &$idx, bool $allElements = false): void
  441.     {
  442.     }
  444.     final public function getDefaultFilterParameters(): array
  445.     {
  446.         return array_merge(
  447.             $this->getDefaultSortValues(),
  448.             $this->getDefaultFilterValues()
  449.         );
  450.     }
  452.     final public function getFilterParameters(): array
  453.     {
  454.         $parameters = $this->getDefaultFilterParameters();
  456.         // build the values array
  457.         if ($this->hasRequest()) {
  458.             /** @var InputBag|ParameterBag $bag */
  459.             $bag = $this->getRequest()->query;
  460.             if ($bag instanceof InputBag) {
  461.                 // symfony 5.1+
  462.                 $filters = $bag->all('filter');
  463.             } else {
  464.                 $filters = $bag->get('filter', []);
  465.                 \assert(\is_array($filters));
  466.             }
  468.             if (isset($filters[DatagridInterface::PAGE])) {
  469.                 $filters[DatagridInterface::PAGE] = (int) $filters[DatagridInterface::PAGE];
  470.             }
  471.             if (isset($filters[DatagridInterface::PER_PAGE])) {
  472.                 $filters[DatagridInterface::PER_PAGE] = (int) $filters[DatagridInterface::PER_PAGE];
  473.             }
  475.             // if filter persistence is configured
  476.             if ($this->hasFilterPersister()) {
  477.                 // if reset filters is asked, remove from storage
  478.                 if ('reset' === $this->getRequest()->query->get('filters')) {
  479.                     $this->getFilterPersister()->reset($this->getCode());
  480.                 }
  482.                 // if no filters, fetch from storage
  483.                 // otherwise save to storage
  484.                 if ([] === $filters) {
  485.                     $filters = $this->getFilterPersister()->get($this->getCode());
  486.                 } else {
  487.                     $this->getFilterPersister()->set($this->getCode(), $filters);
  488.                 }
  489.             }
  491.             $parameters = ParametersManipulator::merge($parameters, $filters);
  493.             // always force the parent value
  494.             if ($this->isChild()) {
  495.                 $parentAssociationMapping = $this->getParentAssociationMapping();
  496.                 if (null !== $parentAssociationMapping) {
  497.                     $name = str_replace('.', '__', $parentAssociationMapping);
  498.                     $parameters[$name] = ['value' => $this->getRequest()->get($this->getParent()->getIdParameter())];
  499.                 }
  500.             }
  501.         }
  503.         if (
  504.             !isset($parameters[DatagridInterface::PER_PAGE])
  505.             || !\is_int($parameters[DatagridInterface::PER_PAGE])
  506.             || !$this->determinedPerPageValue($parameters[DatagridInterface::PER_PAGE])
  507.         ) {
  508.             $parameters[DatagridInterface::PER_PAGE] = $this->getMaxPerPage();
  509.         }
  511.         $parameters = $this->configureFilterParameters($parameters);
  513.         foreach ($this->getExtensions() as $extension) {
  514.             $parameters = $extension->configureFilterParameters($this, $parameters);
  515.         }
  517.         return $parameters;
  518.     }
  520.     /**
  521.      * Returns the name of the parent related field, so the field can be use to set the default
  522.      * value (ie the parent object) or to filter the object.
  523.      *
  524.      * @throws \LogicException
  525.      */
  526.     final public function getParentAssociationMapping(): ?string
  527.     {
  528.         if (!$this->isChild()) {
  529.             throw new \LogicException(sprintf(
  530.                 'Admin "%s" has no parent.',
  531.                 static::class
  532.             ));
  533.         }
  535.         $parent = $this->getParent()->getCode();
  537.         return $this->parentAssociationMapping[$parent];
  538.     }
  540.     final public function getBaseRoutePattern(): string
  541.     {
  542.         if (null !== $this->cachedBaseRoutePattern) {
  543.             return $this->cachedBaseRoutePattern;
  544.         }
  546.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route pattern
  547.             $this->cachedBaseRoutePattern = sprintf(
  548.                 '%s/%s/%s',
  549.                 $this->getParent()->getBaseRoutePattern(),
  550.                 $this->getParent()->getRouterIdParameter(),
  551.                 $this->generateBaseRoutePattern(true)
  552.             );
  553.         } else {
  554.             $this->cachedBaseRoutePattern = $this->generateBaseRoutePattern();
  555.         }
  557.         return $this->cachedBaseRoutePattern;
  558.     }
  560.     /**
  561.      * Returns the baseRouteName used to generate the routing information.
  562.      *
  563.      * @return string the baseRouteName used to generate the routing information
  564.      */
  565.     final public function getBaseRouteName(): string
  566.     {
  567.         if (null !== $this->cachedBaseRouteName) {
  568.             return $this->cachedBaseRouteName;
  569.         }
  571.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route name
  572.             $this->cachedBaseRouteName = sprintf(
  573.                 '%s_%s',
  574.                 $this->getParent()->getBaseRouteName(),
  575.                 $this->generateBaseRouteName(true)
  576.             );
  577.         } else {
  578.             $this->cachedBaseRouteName = $this->generateBaseRouteName();
  579.         }
  581.         return $this->cachedBaseRouteName;
  582.     }
  584.     final public function getClass(): string
  585.     {
  586.         if ($this->hasActiveSubClass()) {
  587.             if ($this->hasParentFieldDescription()) {
  588.                 throw new \LogicException('Feature not implemented: an embedded admin cannot have subclass');
  589.             }
  591.             $subClass = $this->getRequest()->query->get('subclass');
  592.             \assert(\is_string($subClass));
  594.             if (!$this->hasSubClass($subClass)) {
  595.                 throw new \LogicException(sprintf('Subclass "%s" is not defined.', $subClass));
  596.             }
  598.             return $this->getSubClass($subClass);
  599.         }
  601.         // Do not use `$this->hasSubject()` and `$this->getSubject()` here to avoid infinite loop.
  602.         // `getSubject` use `hasSubject()` which use `getObject()` which use `getClass()`.
  603.         if (null !== $this->subject) {
  604.             $modelManager = $this->getModelManager();
  605.             /** @phpstan-var class-string<T> $class */
  606.             $class = $modelManager instanceof ProxyResolverInterface
  607.                 ? $modelManager->getRealClass($this->subject)
  608.                 // NEXT_MAJOR: Change to `\get_class($this->subject)` instead
  609.                 : BCHelper::getClass($this->subject);
  611.             return $class;
  612.         }
  614.         return $this->getModelClass();
  615.     }
  617.     final public function getSubClasses(): array
  618.     {
  619.         return $this->subClasses;
  620.     }
  622.     final public function setSubClasses(array $subClasses): void
  623.     {
  624.         $this->subClasses = $subClasses;
  625.     }
  627.     final public function hasSubClass(string $name): bool
  628.     {
  629.         return isset($this->subClasses[$name]);
  630.     }
  632.     final public function hasActiveSubClass(): bool
  633.     {
  634.         if (\count($this->subClasses) > 0 && $this->hasRequest()) {
  635.             return \is_string($this->getRequest()->query->get('subclass'));
  636.         }
  638.         return false;
  639.     }
  641.     final public function getActiveSubClass(): string
  642.     {
  643.         if (!$this->hasActiveSubClass()) {
  644.             throw new \LogicException(sprintf(
  645.                 'Admin "%s" has no active subclass.',
  646.                 static::class
  647.             ));
  648.         }
  650.         return $this->getSubClass($this->getActiveSubclassCode());
  651.     }
  653.     final public function getActiveSubclassCode(): string
  654.     {
  655.         if (!$this->hasActiveSubClass()) {
  656.             throw new \LogicException(sprintf(
  657.                 'Admin "%s" has no active subclass.',
  658.                 static::class
  659.             ));
  660.         }
  662.         $subClass = (string) $this->getRequest()->query->get('subclass');
  664.         if (!$this->hasSubClass($subClass)) {
  665.             throw new \LogicException(sprintf(
  666.                 'Admin "%s" has no active subclass.',
  667.                 static::class
  668.             ));
  669.         }
  671.         return $subClass;
  672.     }
  674.     final public function getBatchActions(): array
  675.     {
  676.         if (!$this->hasRoute('batch')) {
  677.             return [];
  678.         }
  680.         $actions = [];
  682.         if ($this->hasRoute('delete') && $this->hasAccess('delete')) {
  683.             $actions['delete'] = [
  684.                 'label' => 'action_delete',
  685.                 'translation_domain' => 'SonataAdminBundle',
  686.                 'ask_confirmation' => true, // by default always true
  687.             ];
  688.         }
  690.         $actions = $this->configureBatchActions($actions);
  692.         foreach ($this->getExtensions() as $extension) {
  693.             $actions = $extension->configureBatchActions($this, $actions);
  694.         }
  696.         foreach ($actions as $name => &$action) {
  697.             if (!\array_key_exists('label', $action)) {
  698.                 $action['label'] = $this->getTranslationLabel($name, 'batch', 'label');
  699.             }
  701.             if (!\array_key_exists('translation_domain', $action)) {
  702.                 $action['translation_domain'] = $this->getTranslationDomain();
  703.             }
  704.         }
  706.         return $actions;
  707.     }
  709.     final public function getRoutes(): RouteCollectionInterface
  710.     {
  711.         $routes = $this->buildRoutes();
  712.         if (null === $routes) {
  713.             throw new \LogicException('Cannot access routes during the building process.');
  714.         }
  716.         return $routes;
  717.     }
  719.     public function getRouterIdParameter(): string
  720.     {
  721.         return sprintf('{%s}', $this->getIdParameter());
  722.     }
  724.     public function getIdParameter(): string
  725.     {
  726.         $parameter = 'id';
  728.         for ($i = 0; $i < $this->getChildDepth(); ++$i) {
  729.             $parameter = sprintf('child%s', ucfirst($parameter));
  730.         }
  732.         return $parameter;
  733.     }
  735.     final public function hasRoute(string $name): bool
  736.     {
  737.         return $this->getRouteGenerator()->hasAdminRoute($this, $name);
  738.     }
  740.     final public function isCurrentRoute(string $name, ?string $adminCode = null): bool
  741.     {
  742.         if (!$this->hasRequest()) {
  743.             return false;
  744.         }
  746.         $request = $this->getRequest();
  747.         $route = $request->get('_route');
  749.         if (null !== $adminCode) {
  750.             $pool = $this->getConfigurationPool();
  752.             if ($pool->hasAdminByAdminCode($adminCode)) {
  753.                 $admin = $pool->getAdminByAdminCode($adminCode);
  754.             } else {
  755.                 return false;
  756.             }
  757.         } else {
  758.             $admin = $this;
  759.         }
  761.         return $admin->getRoutes()->getRouteName($name) === $route;
  762.     }
  764.     final public function generateObjectUrl(string $name, object $object, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  765.     {
  766.         $parameters[$this->getIdParameter()] = $this->getUrlSafeIdentifier($object);
  768.         return $this->generateUrl($name, $parameters, $referenceType);
  769.     }
  771.     final public function generateUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  772.     {
  773.         return $this->getRouteGenerator()->generateUrl($this, $name, $parameters, $referenceType);
  774.     }
  776.     final public function generateMenuUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): array
  777.     {
  778.         return $this->getRouteGenerator()->generateMenuUrl($this, $name, $parameters, $referenceType);
  779.     }
  781.     final public function getNewInstance(): object
  782.     {
  783.         $object = $this->createNewInstance();
  785.         $this->alterNewInstance($object);
  787.         foreach ($this->getExtensions() as $extension) {
  788.             $extension->alterNewInstance($this, $object);
  789.         }
  791.         return $object;
  792.     }
  794.     final public function getFormBuilder(): FormBuilderInterface
  795.     {
  796.         $formBuilder = $this->getFormContractor()->getFormBuilder(
  797.             $this->getUniqId(),
  798.             ['data_class' => $this->getClass()] + $this->getFormOptions(),
  799.         );
  801.         $this->defineFormBuilder($formBuilder);
  803.         return $formBuilder;
  804.     }
  806.     /**
  807.      * This method is being called by the main admin class and the child class,
  808.      * the getFormBuilder is only call by the main admin class.
  809.      */
  810.     final public function defineFormBuilder(FormBuilderInterface $formBuilder): void
  811.     {
  812.         if (!$this->hasSubject()) {
  813.             throw new \LogicException(sprintf(
  814.                 'Admin "%s" has no subject.',
  815.                 static::class
  816.             ));
  817.         }
  819.         $mapper = new FormMapper($this->getFormContractor(), $formBuilder, $this);
  821.         $this->configureFormFields($mapper);
  823.         foreach ($this->getExtensions() as $extension) {
  824.             $extension->configureFormFields($mapper);
  825.         }
  826.     }
  828.     final public function attachAdminClass(FieldDescriptionInterface $fieldDescription): void
  829.     {
  830.         $pool = $this->getConfigurationPool();
  832.         try {
  833.             $admin = $pool->getAdminByFieldDescription($fieldDescription);
  834.         } catch (AdminClassNotFoundException $exception) {
  835.             // Using a fieldDescription with no admin class for the target model is a valid case.
  836.             // Since there is no easy way to check for this case, we catch the exception instead.
  837.             return;
  838.         }
  840.         if ($this->hasRequest()) {
  841.             $admin->setRequest($this->getRequest());
  842.         }
  844.         $fieldDescription->setAssociationAdmin($admin);
  845.     }
  847.     /**
  848.      * @param string|int|null $id
  849.      *
  850.      * @phpstan-return T|null
  851.      */
  852.     final public function getObject($id): ?object
  853.     {
  854.         if (null === $id) {
  855.             return null;
  856.         }
  858.         $object = $this->getModelManager()->find($this->getClass(), $id);
  859.         if (null === $object) {
  860.             return null;
  861.         }
  863.         $this->alterObject($object);
  864.         foreach ($this->getExtensions() as $extension) {
  865.             $extension->alterObject($this, $object);
  866.         }
  868.         return $object;
  869.     }
  871.     final public function getForm(): FormInterface
  872.     {
  873.         $form = $this->buildForm();
  874.         if (null === $form) {
  875.             throw new \LogicException('Cannot access form during the building process.');
  876.         }
  878.         return $form;
  879.     }
  881.     final public function getList(): FieldDescriptionCollection
  882.     {
  883.         $list = $this->buildList();
  884.         if (null === $list) {
  885.             throw new \LogicException('Cannot access list during the building process.');
  886.         }
  888.         return $list;
  889.     }
  891.     final public function createQuery(): ProxyQueryInterface
  892.     {
  893.         $query = $this->getModelManager()->createQuery($this->getClass());
  895.         $query = $this->configureQuery($query);
  896.         foreach ($this->getExtensions() as $extension) {
  897.             $extension->configureQuery($this, $query);
  898.         }
  900.         return $query;
  901.     }
  903.     final public function getDatagrid(): DatagridInterface
  904.     {
  905.         $datagrid = $this->buildDatagrid();
  906.         if (null === $datagrid) {
  907.             throw new \LogicException('Cannot access datagrid during the building process.');
  908.         }
  910.         return $datagrid;
  911.     }
  913.     final public function getSideMenu(string $action, ?AdminInterface $childAdmin = null): ItemInterface
  914.     {
  915.         if ($this->isChild()) {
  916.             return $this->getParent()->getSideMenu($action, $this);
  917.         }
  919.         $menu = $this->buildTabMenu($action, $childAdmin);
  920.         if (null === $menu) {
  921.             throw new \LogicException('Cannot access menu during the building process.');
  922.         }
  924.         return $menu;
  925.     }
  927.     final public function getRootCode(): string
  928.     {
  929.         return $this->getRoot()->getCode();
  930.     }
  932.     final public function getRoot(): AdminInterface
  933.     {
  934.         if (!$this->hasParentFieldDescription()) {
  935.             return $this;
  936.         }
  938.         return $this->getParentFieldDescription()->getAdmin()->getRoot();
  939.     }
  941.     final public function getMaxPerPage(): int
  942.     {
  943.         $sortValues = $this->getDefaultSortValues();
  945.         return $sortValues[DatagridInterface::PER_PAGE] ?? self::DEFAULT_LIST_PER_PAGE_RESULTS;
  946.     }
  948.     final public function setMaxPageLinks(int $maxPageLinks): void
  949.     {
  950.         $this->maxPageLinks = $maxPageLinks;
  951.     }
  953.     final public function getMaxPageLinks(): int
  954.     {
  955.         return $this->maxPageLinks;
  956.     }
  958.     final public function getFormGroups(): array
  959.     {
  960.         return $this->formGroups;
  961.     }
  963.     final public function setFormGroups(array $formGroups): void
  964.     {
  965.         $this->formGroups = $formGroups;
  966.     }
  968.     final public function removeFieldFromFormGroup(string $key): void
  969.     {
  970.         foreach ($this->formGroups as $name => $_formGroup) {
  971.             unset($this->formGroups[$name]['fields'][$key]);
  973.             if ([] === $this->formGroups[$name]['fields']) {
  974.                 unset($this->formGroups[$name]);
  975.             }
  976.         }
  977.     }
  979.     final public function reorderFormGroup(string $group, array $keys): void
  980.     {
  981.         $formGroups = $this->getFormGroups();
  982.         $formGroups[$group]['fields'] = array_merge(array_flip($keys), $formGroups[$group]['fields']);
  983.         $this->setFormGroups($formGroups);
  984.     }
  986.     final public function getFormTabs(): array
  987.     {
  988.         return $this->formTabs;
  989.     }
  991.     final public function setFormTabs(array $formTabs): void
  992.     {
  993.         $this->formTabs = $formTabs;
  994.     }
  996.     final public function getShowTabs(): array
  997.     {
  998.         return $this->showTabs;
  999.     }
  1001.     final public function setShowTabs(array $showTabs): void
  1002.     {
  1003.         $this->showTabs = $showTabs;
  1004.     }
  1006.     final public function getShowGroups(): array
  1007.     {
  1008.         return $this->showGroups;
  1009.     }
  1011.     final public function setShowGroups(array $showGroups): void
  1012.     {
  1013.         $this->showGroups = $showGroups;
  1014.     }
  1016.     final public function removeFieldFromShowGroup(string $key): void
  1017.     {
  1018.         foreach ($this->showGroups as $name => $_showGroup) {
  1019.             unset($this->showGroups[$name]['fields'][$key]);
  1021.             if ([] === $this->showGroups[$name]['fields']) {
  1022.                 unset($this->showGroups[$name]);
  1023.             }
  1024.         }
  1025.     }
  1027.     final public function reorderShowGroup(string $group, array $keys): void
  1028.     {
  1029.         $showGroups = $this->getShowGroups();
  1030.         $showGroups[$group]['fields'] = array_merge(array_flip($keys), $showGroups[$group]['fields']);
  1031.         $this->setShowGroups($showGroups);
  1032.     }
  1034.     final public function setParentFieldDescription(FieldDescriptionInterface $parentFieldDescription): void
  1035.     {
  1036.         $this->parentFieldDescription = $parentFieldDescription;
  1037.     }
  1039.     final public function getParentFieldDescription(): FieldDescriptionInterface
  1040.     {
  1041.         if (!$this->hasParentFieldDescription()) {
  1042.             throw new \LogicException(sprintf(
  1043.                 'Admin "%s" has no parent field description.',
  1044.                 static::class
  1045.             ));
  1046.         }
  1048.         return $this->parentFieldDescription;
  1049.     }
  1051.     /**
  1052.      * @phpstan-assert-if-true !null $this->parentFieldDescription
  1053.      */
  1054.     final public function hasParentFieldDescription(): bool
  1055.     {
  1056.         return null !== $this->parentFieldDescription;
  1057.     }
  1059.     final public function setSubject(?object $subject): void
  1060.     {
  1061.         if (null !== $subject && !is_a($subject, $this->getModelClass(), true)) {
  1062.             throw new \LogicException(sprintf(
  1063.                 'Admin "%s" does not allow this subject: %s, use the one register with this admin class %s',
  1064.                 static::class,
  1065.                 \get_class($subject),
  1066.                 $this->getModelClass()
  1067.             ));
  1068.         }
  1070.         $this->subject = $subject;
  1071.     }
  1073.     final public function getSubject(): object
  1074.     {
  1075.         if (!$this->hasSubject()) {
  1076.             throw new \LogicException(sprintf(
  1077.                 'Admin "%s" has no subject.',
  1078.                 static::class
  1079.             ));
  1080.         }
  1082.         return $this->subject;
  1083.     }
  1085.     /**
  1086.      * @phpstan-assert-if-true !null $this->subject
  1087.      */
  1088.     final public function hasSubject(): bool
  1089.     {
  1090.         if (null === $this->subject && $this->hasRequest() && !$this->hasParentFieldDescription()) {
  1091.             $id = $this->getRequest()->get($this->getIdParameter());
  1093.             if (null !== $id) {
  1094.                 $this->subject = $this->getObject($id);
  1095.             }
  1096.         }
  1098.         return null !== $this->subject;
  1099.     }
  1101.     final public function getFormFieldDescriptions(): array
  1102.     {
  1103.         $this->buildForm();
  1105.         return $this->formFieldDescriptions;
  1106.     }
  1108.     final public function getFormFieldDescription(string $name): FieldDescriptionInterface
  1109.     {
  1110.         $this->buildForm();
  1112.         if (!$this->hasFormFieldDescription($name)) {
  1113.             throw new \LogicException(sprintf(
  1114.                 'Admin "%s" has no form field description for the field %s.',
  1115.                 static::class,
  1116.                 $name
  1117.             ));
  1118.         }
  1120.         return $this->formFieldDescriptions[$name];
  1121.     }
  1123.     /**
  1124.      * Returns true if the admin has a FieldDescription with the given $name.
  1125.      */
  1126.     final public function hasFormFieldDescription(string $name): bool
  1127.     {
  1128.         $this->buildForm();
  1130.         return \array_key_exists($name, $this->formFieldDescriptions);
  1131.     }
  1133.     final public function addFormFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1134.     {
  1135.         $this->formFieldDescriptions[$name] = $fieldDescription;
  1136.     }
  1138.     /**
  1139.      * remove a FieldDescription.
  1140.      */
  1141.     final public function removeFormFieldDescription(string $name): void
  1142.     {
  1143.         unset($this->formFieldDescriptions[$name]);
  1144.     }
  1146.     /**
  1147.      * build and return the collection of form FieldDescription.
  1148.      *
  1149.      * @return FieldDescriptionInterface[] collection of form FieldDescription
  1150.      */
  1151.     final public function getShowFieldDescriptions(): array
  1152.     {
  1153.         $this->buildShow();
  1155.         return $this->showFieldDescriptions;
  1156.     }
  1158.     /**
  1159.      * Returns the form FieldDescription with the given $name.
  1160.      */
  1161.     final public function getShowFieldDescription(string $name): FieldDescriptionInterface
  1162.     {
  1163.         $this->buildShow();
  1165.         if (!$this->hasShowFieldDescription($name)) {
  1166.             throw new \LogicException(sprintf(
  1167.                 'Admin "%s" has no show field description for the field %s.',
  1168.                 static::class,
  1169.                 $name
  1170.             ));
  1171.         }
  1173.         return $this->showFieldDescriptions[$name];
  1174.     }
  1176.     final public function hasShowFieldDescription(string $name): bool
  1177.     {
  1178.         $this->buildShow();
  1180.         return \array_key_exists($name, $this->showFieldDescriptions);
  1181.     }
  1183.     final public function addShowFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1184.     {
  1185.         $this->showFieldDescriptions[$name] = $fieldDescription;
  1186.     }
  1188.     final public function removeShowFieldDescription(string $name): void
  1189.     {
  1190.         unset($this->showFieldDescriptions[$name]);
  1191.     }
  1193.     final public function getListFieldDescriptions(): array
  1194.     {
  1195.         $this->buildList();
  1197.         return $this->listFieldDescriptions;
  1198.     }
  1200.     final public function getListFieldDescription(string $name): FieldDescriptionInterface
  1201.     {
  1202.         $this->buildList();
  1204.         if (!$this->hasListFieldDescription($name)) {
  1205.             throw new \LogicException(sprintf(
  1206.                 'Admin "%s" has no list field description for %s.',
  1207.                 static::class,
  1208.                 $name
  1209.             ));
  1210.         }
  1212.         return $this->listFieldDescriptions[$name];
  1213.     }
  1215.     final public function hasListFieldDescription(string $name): bool
  1216.     {
  1217.         $this->buildList();
  1219.         return \array_key_exists($name, $this->listFieldDescriptions);
  1220.     }
  1222.     final public function addListFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1223.     {
  1224.         $this->listFieldDescriptions[$name] = $fieldDescription;
  1225.     }
  1227.     final public function removeListFieldDescription(string $name): void
  1228.     {
  1229.         unset($this->listFieldDescriptions[$name]);
  1230.     }
  1232.     final public function getFilterFieldDescription(string $name): FieldDescriptionInterface
  1233.     {
  1234.         $this->buildDatagrid();
  1236.         if (!$this->hasFilterFieldDescription($name)) {
  1237.             throw new \LogicException(sprintf(
  1238.                 'Admin "%s" has no filter field description for the field %s.',
  1239.                 static::class,
  1240.                 $name
  1241.             ));
  1242.         }
  1244.         return $this->filterFieldDescriptions[$name];
  1245.     }
  1247.     final public function hasFilterFieldDescription(string $name): bool
  1248.     {
  1249.         $this->buildDatagrid();
  1251.         return \array_key_exists($name, $this->filterFieldDescriptions);
  1252.     }
  1254.     final public function addFilterFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1255.     {
  1256.         $this->filterFieldDescriptions[$name] = $fieldDescription;
  1257.     }
  1259.     final public function removeFilterFieldDescription(string $name): void
  1260.     {
  1261.         unset($this->filterFieldDescriptions[$name]);
  1262.     }
  1264.     final public function getFilterFieldDescriptions(): array
  1265.     {
  1266.         $this->buildDatagrid();
  1268.         return $this->filterFieldDescriptions;
  1269.     }
  1271.     /**
  1272.      * @psalm-suppress PossiblyNullArgument Will be solved in NEXT_MAJOR
  1273.      */
  1274.     final public function addChild(AdminInterface $child, ?string $field = null): void
  1275.     {
  1276.         $parentAdmin = $this;
  1277.         while ($parentAdmin->isChild() && $parentAdmin->getCode() !== $child->getCode()) {
  1278.             $parentAdmin = $parentAdmin->getParent();
  1279.         }
  1281.         if ($parentAdmin->getCode() === $child->getCode()) {
  1282.             throw new \LogicException(sprintf(
  1283.                 'Circular reference detected! The child admin `%s` is already in the parent tree of the `%s` admin.',
  1284.                 $child->getCode(),
  1285.                 $this->getCode()
  1286.             ));
  1287.         }
  1289.         $this->children[$child->getCode()] = $child;
  1291.         // @phpstan-ignore-next-line Will be solved in NEXT_MAJOR
  1292.         $child->setParent($this, $field);
  1293.     }
  1295.     final public function hasChild(string $code): bool
  1296.     {
  1297.         return isset($this->children[$code]);
  1298.     }
  1300.     final public function getChildren(): array
  1301.     {
  1302.         return $this->children;
  1303.     }
  1305.     final public function getChild(string $code): AdminInterface
  1306.     {
  1307.         if (!$this->hasChild($code)) {
  1308.             throw new \LogicException(sprintf(
  1309.                 'Admin "%s" has no child for the code %s.',
  1310.                 static::class,
  1311.                 $code
  1312.             ));
  1313.         }
  1315.         return $this->getChildren()[$code];
  1316.     }
  1318.     final public function setParent(AdminInterface $parent, ?string $parentAssociationMapping = null): void
  1319.     {
  1320.         $this->parent = $parent;
  1321.         $this->parentAssociationMapping[$parent->getCode()] = $parentAssociationMapping;
  1322.     }
  1324.     final public function getParent(): AdminInterface
  1325.     {
  1326.         if (null === $this->parent) {
  1327.             throw new \LogicException(sprintf(
  1328.                 'Admin "%s" has no parent.',
  1329.                 static::class
  1330.             ));
  1331.         }
  1333.         return $this->parent;
  1334.     }
  1336.     final public function getRootAncestor(): AdminInterface
  1337.     {
  1338.         $parent = $this;
  1340.         while ($parent->isChild()) {
  1341.             $parent = $parent->getParent();
  1342.         }
  1344.         return $parent;
  1345.     }
  1347.     final public function getChildDepth(): int
  1348.     {
  1349.         $parent = $this;
  1350.         $depth = 0;
  1352.         while ($parent->isChild()) {
  1353.             $parent = $parent->getParent();
  1354.             ++$depth;
  1355.         }
  1357.         return $depth;
  1358.     }
  1360.     final public function getCurrentLeafChildAdmin(): ?AdminInterface
  1361.     {
  1362.         $child = $this->getCurrentChildAdmin();
  1364.         if (null === $child) {
  1365.             return null;
  1366.         }
  1368.         for ($c = $child; null !== $c; $c = $child->getCurrentChildAdmin()) {
  1369.             $child = $c;
  1370.         }
  1372.         return $child;
  1373.     }
  1375.     final public function isChild(): bool
  1376.     {
  1377.         return $this->parent instanceof AdminInterface;
  1378.     }
  1380.     /**
  1381.      * Returns true if the admin has children, false otherwise.
  1382.      *
  1383.      * @phpstan-assert-if-true non-empty-array $this->children
  1384.      */
  1385.     final public function hasChildren(): bool
  1386.     {
  1387.         return \count($this->children) > 0;
  1388.     }
  1390.     final public function setUniqId(string $uniqId): void
  1391.     {
  1392.         $this->uniqId = $uniqId;
  1393.     }
  1395.     final public function getUniqId(): string
  1396.     {
  1397.         if (null === $this->uniqId) {
  1398.             $this->uniqId = sprintf('s%s', uniqid());
  1399.         }
  1401.         return $this->uniqId;
  1402.     }
  1404.     final public function getClassnameLabel(): string
  1405.     {
  1406.         if (null === $this->classnameLabel) {
  1407.             throw new \LogicException(sprintf(
  1408.                 'Admin "%s" has no classname label. Did you forgot to initialize the admin ?',
  1409.                 static::class
  1410.             ));
  1411.         }
  1413.         return $this->classnameLabel;
  1414.     }
  1416.     final public function getPersistentParameters(): array
  1417.     {
  1418.         $parameters = $this->configurePersistentParameters();
  1419.         foreach ($this->getExtensions() as $extension) {
  1420.             $parameters = $extension->configurePersistentParameters($this, $parameters);
  1421.         }
  1423.         return $parameters;
  1424.     }
  1426.     final public function getPersistentParameter(string $name, $default = null)
  1427.     {
  1428.         $parameters = $this->getPersistentParameters();
  1430.         return $parameters[$name] ?? $default;
  1431.     }
  1433.     final public function setCurrentChild(bool $currentChild): void
  1434.     {
  1435.         $this->currentChild = $currentChild;
  1436.     }
  1438.     final public function isCurrentChild(): bool
  1439.     {
  1440.         return $this->currentChild;
  1441.     }
  1443.     final public function getCurrentChildAdmin(): ?AdminInterface
  1444.     {
  1445.         foreach ($this->getChildren() as $child) {
  1446.             if ($child->isCurrentChild()) {
  1447.                 return $child;
  1448.             }
  1449.         }
  1451.         return null;
  1452.     }
  1454.     final public function setTranslationDomain(string $translationDomain): void
  1455.     {
  1456.         $this->translationDomain = $translationDomain;
  1457.     }
  1459.     final public function getTranslationDomain(): string
  1460.     {
  1461.         return $this->translationDomain;
  1462.     }
  1464.     final public function getTranslationLabel(string $label, string $context = '', string $type = ''): string
  1465.     {
  1466.         return $this->getLabelTranslatorStrategy()->getLabel($label, $context, $type);
  1467.     }
  1469.     final public function setRequest(Request $request): void
  1470.     {
  1471.         $this->request = $request;
  1473.         foreach ($this->getChildren() as $children) {
  1474.             $children->setRequest($request);
  1475.         }
  1476.     }
  1478.     final public function getRequest(): Request
  1479.     {
  1480.         if (!$this->hasRequest()) {
  1481.             throw new \LogicException('The Request object has not been set');
  1482.         }
  1484.         return $this->request;
  1485.     }
  1487.     /**
  1488.      * @phpstan-assert-if-true !null $this->request
  1489.      */
  1490.     final public function hasRequest(): bool
  1491.     {
  1492.         return null !== $this->request;
  1493.     }
  1495.     final public function getBaseCodeRoute(): string
  1496.     {
  1497.         if ($this->isChild()) {
  1498.             return $this->getParent()->getBaseCodeRoute().'|'.$this->getCode();
  1499.         }
  1501.         return $this->getCode();
  1502.     }
  1504.     /**
  1505.      * @return string
  1506.      */
  1507.     public function getObjectIdentifier()
  1508.     {
  1509.         return $this->getCode();
  1510.     }
  1512.     public function showInDashboard(): bool
  1513.     {
  1514.         // NEXT_MAJOR: Remove those lines and uncomment the last one.
  1515.         $permissionShow = $this->getPermissionsShow(self::CONTEXT_DASHBOARD, 'sonata_deprecation_mute');
  1516.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1518.         return $this->isGranted($permission);
  1519.         // return $this->isGranted('LIST');
  1520.     }
  1522.     /**
  1523.      * NEXT_MAJOR: Remove this method.
  1524.      *
  1525.      * @deprecated since sonata-project/admin-bundle version 4.7 use showInDashboard instead
  1526.      */
  1527.     final public function showIn(string $context): bool
  1528.     {
  1529.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  1530.             @trigger_error(sprintf(
  1531.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  1532.                 .' removed in 5.0 version. Use showInDashboard() instead.',
  1533.                 __METHOD__
  1534.             ), \E_USER_DEPRECATED);
  1535.         }
  1537.         $permissionShow = $this->getPermissionsShow($context, 'sonata_deprecation_mute');
  1538.         // Avoid isGranted deprecation if there is only one permission show.
  1539.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1541.         return $this->isGranted($permission);
  1542.     }
  1544.     final public function createObjectSecurity(object $object): void
  1545.     {
  1546.         $this->getSecurityHandler()->createObjectSecurity($this, $object);
  1547.     }
  1549.     final public function isGranted($name, ?object $object = null): bool
  1550.     {
  1551.         if (\is_array($name)) {
  1552.             @trigger_error(
  1553.                 sprintf(
  1554.                     'Passing an array as argument 1 of "%s()" is deprecated since sonata-project/admin-bundle 4.6'
  1555.                     .' and will throw an error in 5.0. You MUST pass a string instead.',
  1556.                     __METHOD__
  1557.                 ),
  1558.                 \E_USER_DEPRECATED
  1559.             );
  1560.         }
  1562.         $objectRef = null !== $object ? sprintf('/%s#%s', spl_object_hash($object), $this->id($object) ?? '') : '';
  1563.         $key = md5(json_encode($name, \JSON_THROW_ON_ERROR).$objectRef);
  1565.         if (!\array_key_exists($key, $this->cacheIsGranted)) {
  1566.             $this->cacheIsGranted[$key] = $this->getSecurityHandler()->isGranted($this, $name, $object ?? $this);
  1567.         }
  1569.         return $this->cacheIsGranted[$key];
  1570.     }
  1572.     final public function getUrlSafeIdentifier(object $model): ?string
  1573.     {
  1574.         return $this->getModelManager()->getUrlSafeIdentifier($model);
  1575.     }
  1577.     final public function getNormalizedIdentifier(object $model): ?string
  1578.     {
  1579.         return $this->getModelManager()->getNormalizedIdentifier($model);
  1580.     }
  1582.     public function id(object $model): ?string
  1583.     {
  1584.         return $this->getNormalizedIdentifier($model);
  1585.     }
  1587.     final public function getShow(): FieldDescriptionCollection
  1588.     {
  1589.         $show = $this->buildShow();
  1590.         if (null === $show) {
  1591.             throw new \LogicException('Cannot access show during the building process.');
  1592.         }
  1594.         return $show;
  1595.     }
  1597.     final public function setFormTheme(array $formTheme): void
  1598.     {
  1599.         $this->formTheme = $formTheme;
  1600.     }
  1602.     final public function getFormTheme(): array
  1603.     {
  1604.         return $this->formTheme;
  1605.     }
  1607.     final public function setFilterTheme(array $filterTheme): void
  1608.     {
  1609.         $this->filterTheme = $filterTheme;
  1610.     }
  1612.     final public function getFilterTheme(): array
  1613.     {
  1614.         return $this->filterTheme;
  1615.     }
  1617.     final public function addExtension(AdminExtensionInterface $extension): void
  1618.     {
  1619.         $this->extensions[] = $extension;
  1620.     }
  1622.     /**
  1623.      * @phpstan-param AdminExtensionInterface<T> $extension
  1624.      */
  1625.     final public function removeExtension(AdminExtensionInterface $extension): void
  1626.     {
  1627.         $key = array_search($extension, $this->extensions, true);
  1628.         if (false === $key) {
  1629.             throw new \InvalidArgumentException(
  1630.                 sprintf('The extension "%s" was not set to the "%s" admin.', \get_class($extension), self::class)
  1631.             );
  1632.         }
  1634.         unset($this->extensions[$key]);
  1635.     }
  1637.     final public function getExtensions(): array
  1638.     {
  1639.         return $this->extensions;
  1640.     }
  1642.     public function toString(object $object): string
  1643.     {
  1644.         if (method_exists($object, '__toString') && null !== $object->__toString()) {
  1645.             return $object->__toString();
  1646.         }
  1648.         $modelManager = $this->getModelManager();
  1649.         if ($modelManager instanceof ProxyResolverInterface) {
  1650.             $class = $modelManager->getRealClass($object);
  1651.         } else {
  1652.             // NEXT_MAJOR: Change to `\get_class($object)`
  1653.             $class = BCHelper::getClass($object);
  1654.         }
  1656.         return sprintf('%s:%s', $class, spl_object_hash($object));
  1657.     }
  1659.     final public function supportsPreviewMode(): bool
  1660.     {
  1661.         return $this->supportsPreviewMode;
  1662.     }
  1664.     /**
  1665.      * Returns predefined per page options.
  1666.      *
  1667.      * @return array<int>
  1668.      */
  1669.     public function getPerPageOptions(): array
  1670.     {
  1671.         $perPageOptions = self::DEFAULT_LIST_PER_PAGE_OPTIONS;
  1672.         $perPageOptions[] = $this->getMaxPerPage();
  1674.         $perPageOptions = array_unique($perPageOptions);
  1675.         sort($perPageOptions);
  1677.         return $perPageOptions;
  1678.     }
  1680.     /**
  1681.      * Returns true if the per page value is allowed, false otherwise.
  1682.      */
  1683.     final public function determinedPerPageValue(int $perPage): bool
  1684.     {
  1685.         return \in_array($perPage, $this->getPerPageOptions(), true);
  1686.     }
  1688.     final public function isAclEnabled(): bool
  1689.     {
  1690.         return $this->getSecurityHandler() instanceof AclSecurityHandlerInterface;
  1691.     }
  1693.     public function getObjectMetadata(object $object): MetadataInterface
  1694.     {
  1695.         return new Metadata($this->toString($object));
  1696.     }
  1698.     final public function setListMode(string $mode): void
  1699.     {
  1700.         $this->getRequest()->getSession()->set(sprintf('%s.list_mode', $this->getCode()), $mode);
  1701.     }
  1703.     final public function getListMode(): string
  1704.     {
  1705.         $defaultListMode = array_keys($this->getListModes())[0];
  1706.         if (!$this->hasRequest() || !$this->getRequest()->hasSession()) {
  1707.             return $defaultListMode;
  1708.         }
  1710.         return $this->getRequest()->getSession()->get(sprintf('%s.list_mode', $this->getCode()), $defaultListMode);
  1711.     }
  1713.     final public function checkAccess(string $action, ?object $object = null): void
  1714.     {
  1715.         $access = $this->getAccess();
  1717.         if (!\array_key_exists($action, $access)) {
  1718.             throw new \InvalidArgumentException(sprintf(
  1719.                 'Action "%s" could not be found in access mapping.'
  1720.                 .' Please make sure your action is defined into your admin class accessMapping property.',
  1721.                 $action
  1722.             ));
  1723.         }
  1725.         if (!\is_array($access[$action])) {
  1726.             $access[$action] = [$access[$action]];
  1727.         }
  1729.         foreach ($access[$action] as $role) {
  1730.             if (false === $this->isGranted($role, $object)) {
  1731.                 throw new AccessDeniedException(sprintf('Access Denied to the action %s and role %s', $action, $role));
  1732.             }
  1733.         }
  1734.     }
  1736.     final public function hasAccess(string $action, ?object $object = null): bool
  1737.     {
  1738.         $access = $this->getAccess();
  1740.         if (!\array_key_exists($action, $access)) {
  1741.             return false;
  1742.         }
  1744.         if (!\is_array($access[$action])) {
  1745.             $access[$action] = [$access[$action]];
  1746.         }
  1748.         foreach ($access[$action] as $role) {
  1749.             if (false === $this->isGranted($role, $object)) {
  1750.                 return false;
  1751.             }
  1752.         }
  1754.         return true;
  1755.     }
  1757.     /**
  1758.      * @return array<string, array<string, mixed>>
  1759.      *
  1760.      * @phpstan-param T|null $object
  1761.      */
  1762.     final public function getActionButtons(string $action, ?object $object = null): array
  1763.     {
  1764.         $defaultButtonList = $this->getDefaultActionButtons($action, $object);
  1765.         $buttonList = $this->configureActionButtons($defaultButtonList, $action, $object);
  1767.         foreach ($this->getExtensions() as $extension) {
  1768.             $buttonList = $extension->configureActionButtons($this, $buttonList, $action, $object);
  1769.         }
  1771.         return $buttonList;
  1772.     }
  1774.     /**
  1775.      * Get the list of actions that can be accessed directly from the dashboard.
  1776.      *
  1777.      * @return array<string, array<string, mixed>>
  1778.      */
  1779.     final public function getDashboardActions(): array
  1780.     {
  1781.         $actions = [];
  1783.         if ($this->hasRoute('create') && $this->hasAccess('create')) {
  1784.             $actions['create'] = [
  1785.                 'label' => 'link_add',
  1786.                 'translation_domain' => 'SonataAdminBundle',
  1787.                 'template' => $this->getTemplateRegistry()->getTemplate('action_create'),
  1788.                 'url' => $this->generateUrl('create'),
  1789.                 'icon' => 'fas fa-plus-circle',
  1790.             ];
  1791.         }
  1793.         if ($this->hasRoute('list') && $this->hasAccess('list')) {
  1794.             $actions['list'] = [
  1795.                 'label' => 'link_list',
  1796.                 'translation_domain' => 'SonataAdminBundle',
  1797.                 'url' => $this->generateUrl('list'),
  1798.                 'icon' => 'fas fa-list',
  1799.             ];
  1800.         }
  1802.         $actions = $this->configureDashboardActions($actions);
  1804.         foreach ($this->getExtensions() as $extension) {
  1805.             $actions = $extension->configureDashboardActions($this, $actions);
  1806.         }
  1808.         return $actions;
  1809.     }
  1811.     final public function createFieldDescription(string $propertyName, array $options = []): FieldDescriptionInterface
  1812.     {
  1813.         $fieldDescriptionFactory = $this->getFieldDescriptionFactory();
  1815.         $fieldDescription = $fieldDescriptionFactory->create($this->getClass(), $propertyName, $options);
  1817.         $fieldDescription->setAdmin($this);
  1819.         return $fieldDescription;
  1820.     }
  1822.     /**
  1823.      * Hook to run after initialization.
  1824.      */
  1825.     protected function configure(): void
  1826.     {
  1827.     }
  1829.     protected function generateBaseRoutePattern(bool $isChildAdmin = false): string
  1830.     {
  1831.         // NEXT_MAJOR: Remove this code
  1832.         if (null !== $this->baseRoutePattern) {
  1833.             @trigger_error(sprintf(
  1834.                 'Overriding the baseRoutePattern property is deprecated since sonata-project/admin-bundle 4.15.'
  1835.                 .' You MUST override the method %s() instead.',
  1836.                 __METHOD__
  1837.             ), \E_USER_DEPRECATED);
  1839.             return $this->baseRoutePattern;
  1840.         }
  1842.         preg_match(self::CLASS_REGEX, $this->getModelClass(), $matches);
  1844.         if ([] === $matches) {
  1845.             throw new \LogicException(sprintf(
  1846.                 'Please define a default `baseRoutePattern` value for the admin class `%s`',
  1847.                 static::class
  1848.             ));
  1849.         }
  1851.         if ($isChildAdmin) {
  1852.             return $this->urlize($matches[5], '-');
  1853.         }
  1855.         return sprintf(
  1856.             '/%s%s/%s',
  1857.             '' === $matches[1] ? '' : $this->urlize($matches[1], '-').'/',
  1858.             $this->urlize($matches[3], '-'),
  1859.             $this->urlize($matches[5], '-')
  1860.         );
  1861.     }
  1863.     protected function generateBaseRouteName(bool $isChildAdmin = false): string
  1864.     {
  1865.         // NEXT_MAJOR: Remove this code
  1866.         if (null !== $this->baseRouteName) {
  1867.             @trigger_error(sprintf(
  1868.                 'Overriding the baseRouteName property is deprecated since sonata-project/admin-bundle 4.15.'
  1869.                 .' You MUST override the method %s() instead.',
  1870.                 __METHOD__
  1871.             ), \E_USER_DEPRECATED);
  1873.             return $this->baseRouteName;
  1874.         }
  1876.         preg_match(self::CLASS_REGEX, $this->getModelClass(), $matches);
  1878.         if ([] === $matches) {
  1879.             throw new \LogicException(sprintf(
  1880.                 'Cannot automatically determine base route name,'
  1881.                 .' please define a default `baseRouteName` value for the admin class `%s`',
  1882.                 static::class
  1883.             ));
  1884.         }
  1886.         if ($isChildAdmin) {
  1887.             return $this->urlize($matches[5]);
  1888.         }
  1890.         return sprintf(
  1891.             'admin_%s%s_%s',
  1892.             '' === $matches[1] ? '' : $this->urlize($matches[1]).'_',
  1893.             $this->urlize($matches[3]),
  1894.             $this->urlize($matches[5])
  1895.         );
  1896.     }
  1898.     /**
  1899.      * @phpstan-return T
  1900.      */
  1901.     protected function createNewInstance(): object
  1902.     {
  1903.         $object = Instantiator::instantiate($this->getClass());
  1904.         $this->appendParentObject($object);
  1906.         return $object;
  1907.     }
  1909.     /**
  1910.      * @phpstan-param T $object
  1911.      */
  1912.     protected function alterNewInstance(object $object): void
  1913.     {
  1914.     }
  1916.     /**
  1917.      * @phpstan-param T $object
  1918.      */
  1919.     protected function alterObject(object $object): void
  1920.     {
  1921.     }
  1923.     /**
  1924.      * @phpstan-param T $object
  1925.      */
  1926.     protected function preValidate(object $object): void
  1927.     {
  1928.     }
  1930.     /**
  1931.      * @phpstan-param T $object
  1932.      */
  1933.     protected function preUpdate(object $object): void
  1934.     {
  1935.     }
  1937.     /**
  1938.      * @phpstan-param T $object
  1939.      */
  1940.     protected function postUpdate(object $object): void
  1941.     {
  1942.     }
  1944.     /**
  1945.      * @phpstan-param T $object
  1946.      */
  1947.     protected function prePersist(object $object): void
  1948.     {
  1949.     }
  1951.     /**
  1952.      * @phpstan-param T $object
  1953.      */
  1954.     protected function postPersist(object $object): void
  1955.     {
  1956.     }
  1958.     /**
  1959.      * @phpstan-param T $object
  1960.      */
  1961.     protected function preRemove(object $object): void
  1962.     {
  1963.     }
  1965.     /**
  1966.      * @phpstan-param T $object
  1967.      */
  1968.     protected function postRemove(object $object): void
  1969.     {
  1970.     }
  1972.     /**
  1973.      * @return array<string, mixed>
  1974.      */
  1975.     protected function configurePersistentParameters(): array
  1976.     {
  1977.         return [];
  1978.     }
  1980.     /**
  1981.      * @return string[]
  1982.      */
  1983.     protected function configureExportFields(): array
  1984.     {
  1985.         return $this->getModelManager()->getExportFields($this->getClass());
  1986.     }
  1988.     /**
  1989.      * @param ProxyQueryInterface<T> $query
  1990.      *
  1991.      * @return ProxyQueryInterface<T>
  1992.      */
  1993.     protected function configureQuery(ProxyQueryInterface $query): ProxyQueryInterface
  1994.     {
  1995.         return $query;
  1996.     }
  1998.     /**
  1999.      * urlize the given word.
  2000.      *
  2001.      * @param string $sep the separator
  2002.      */
  2003.     final protected function urlize(string $word, string $sep = '_'): string
  2004.     {
  2005.         return strtolower(preg_replace('/[^a-z0-9_]/i', $sep.'$1', $word) ?? '');
  2006.     }
  2008.     /**
  2009.      * @param array<string, mixed> $parameters
  2010.      *
  2011.      * @return array<string, mixed>
  2012.      */
  2013.     protected function configureFilterParameters(array $parameters): array
  2014.     {
  2015.         return $parameters;
  2016.     }
  2018.     /**
  2019.      * Returns a list of default sort values.
  2020.      *
  2021.      * @phpstan-return array{
  2022.      *     _page?: int,
  2023.      *     _per_page?: int,
  2024.      *     _sort_by?: string,
  2025.      *     _sort_order?: string
  2026.      * }
  2027.      */
  2028.     final protected function getDefaultSortValues(): array
  2029.     {
  2030.         $defaultSortValues = [DatagridInterface::PAGE => 1, DatagridInterface::PER_PAGE => self::DEFAULT_LIST_PER_PAGE_RESULTS];
  2032.         $this->configureDefaultSortValues($defaultSortValues);
  2034.         foreach ($this->getExtensions() as $extension) {
  2035.             $extension->configureDefaultSortValues($this, $defaultSortValues);
  2036.         }
  2038.         return $defaultSortValues;
  2039.     }
  2041.     /**
  2042.      * Returns a list of default filters.
  2043.      *
  2044.      * @return array<string, array<string, mixed>>
  2045.      */
  2046.     final protected function getDefaultFilterValues(): array
  2047.     {
  2048.         $defaultFilterValues = [];
  2050.         $this->configureDefaultFilterValues($defaultFilterValues);
  2052.         foreach ($this->getExtensions() as $extension) {
  2053.             $extension->configureDefaultFilterValues($this, $defaultFilterValues);
  2054.         }
  2056.         return $defaultFilterValues;
  2057.     }
  2059.     /**
  2060.      * @return array<string, mixed>
  2061.      */
  2062.     final protected function getFormOptions(): array
  2063.     {
  2064.         $formOptions = [];
  2066.         $this->configureFormOptions($formOptions);
  2068.         foreach ($this->getExtensions() as $extension) {
  2069.             $extension->configureFormOptions($this, $formOptions);
  2070.         }
  2072.         return $formOptions;
  2073.     }
  2075.     /**
  2076.      * @phpstan-param FormMapper<T> $form
  2077.      */
  2078.     protected function configureFormFields(FormMapper $form): void
  2079.     {
  2080.     }
  2082.     /**
  2083.      * @phpstan-param ListMapper<T> $list
  2084.      */
  2085.     protected function configureListFields(ListMapper $list): void
  2086.     {
  2087.     }
  2089.     /**
  2090.      * @phpstan-param DatagridMapper<T> $filter
  2091.      */
  2092.     protected function configureDatagridFilters(DatagridMapper $filter): void
  2093.     {
  2094.     }
  2096.     /**
  2097.      * @phpstan-param ShowMapper<T> $show
  2098.      */
  2099.     protected function configureShowFields(ShowMapper $show): void
  2100.     {
  2101.     }
  2103.     protected function configureRoutes(RouteCollectionInterface $collection): void
  2104.     {
  2105.     }
  2107.     /**
  2108.      * @param array<string, array<string, mixed>> $buttonList
  2109.      *
  2110.      * @return array<string, array<string, mixed>>
  2111.      *
  2112.      * @phpstan-param T|null $object
  2113.      */
  2114.     protected function configureActionButtons(array $buttonList, string $action, ?object $object = null): array
  2115.     {
  2116.         return $buttonList;
  2117.     }
  2119.     /**
  2120.      * @param array<string, array<string, mixed>> $actions
  2121.      *
  2122.      * @return array<string, array<string, mixed>>
  2123.      */
  2124.     protected function configureDashboardActions(array $actions): array
  2125.     {
  2126.         return $actions;
  2127.     }
  2129.     /**
  2130.      * Allows you to customize batch actions.
  2131.      *
  2132.      * @param array<string, array<string, mixed>> $actions
  2133.      *
  2134.      * @return array<string, array<string, mixed>>
  2135.      */
  2136.     protected function configureBatchActions(array $actions): array
  2137.     {
  2138.         return $actions;
  2139.     }
  2141.     /**
  2142.      * Configures the tab menu in your admin.
  2143.      *
  2144.      * @phpstan-template TChild of object
  2145.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2146.      */
  2147.     protected function configureTabMenu(ItemInterface $menu, string $action, ?AdminInterface $childAdmin = null): void
  2148.     {
  2149.     }
  2151.     /**
  2152.      * Gets the subclass corresponding to the given name.
  2153.      *
  2154.      * @phpstan-return class-string<T>
  2155.      */
  2156.     protected function getSubClass(string $name): string
  2157.     {
  2158.         if ($this->hasSubClass($name)) {
  2159.             return $this->subClasses[$name];
  2160.         }
  2162.         throw new \LogicException(sprintf('Unable to find the subclass `%s` for admin `%s`', $name, static::class));
  2163.     }
  2165.     /**
  2166.      * Return list routes with permissions name.
  2167.      *
  2168.      * @return array<string, string|string[]>
  2169.      */
  2170.     final protected function getAccess(): array
  2171.     {
  2172.         $access = array_merge([
  2173.             'acl' => AdminPermissionMap::PERMISSION_MASTER,
  2174.             'export' => AdminPermissionMap::PERMISSION_EXPORT,
  2175.             'historyCompareRevisions' => AdminPermissionMap::PERMISSION_HISTORY,
  2176.             'historyViewRevision' => AdminPermissionMap::PERMISSION_HISTORY,
  2177.             'history' => AdminPermissionMap::PERMISSION_HISTORY,
  2178.             'edit' => AdminPermissionMap::PERMISSION_EDIT,
  2179.             'show' => AdminPermissionMap::PERMISSION_VIEW,
  2180.             'create' => AdminPermissionMap::PERMISSION_CREATE,
  2181.             'delete' => AdminPermissionMap::PERMISSION_DELETE,
  2182.             'batchDelete' => AdminPermissionMap::PERMISSION_DELETE,
  2183.             'list' => AdminPermissionMap::PERMISSION_LIST,
  2184.         ], $this->getAccessMapping());
  2186.         foreach ($this->getExtensions() as $extension) {
  2187.             $access = array_merge($access, $extension->getAccessMapping($this));
  2188.         }
  2190.         return $access;
  2191.     }
  2193.     /**
  2194.      * @return array<string, string|string[]> [action1 => requiredRole1, action2 => [requiredRole2, requiredRole3]]
  2195.      */
  2196.     protected function getAccessMapping(): array
  2197.     {
  2198.         return [];
  2199.     }
  2201.     /**
  2202.      * Return the list of permissions the user should have in order to display the admin.
  2203.      *
  2204.      * NEXT_MAJOR: Remove this method.
  2205.      *
  2206.      * @deprecated since sonata-project/admin-bundle version 4.7
  2207.      *
  2208.      * @return string[]
  2209.      */
  2210.     protected function getPermissionsShow(string $context): array
  2211.     {
  2212.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  2213.             @trigger_error(sprintf(
  2214.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  2215.                 .' removed in 5.0 version.',
  2216.                 __METHOD__
  2217.             ), \E_USER_DEPRECATED);
  2218.         }
  2220.         return ['LIST'];
  2221.     }
  2223.     /**
  2224.      * Configures a list of default filters.
  2225.      *
  2226.      * @param array<string, array<string, mixed>> $filterValues
  2227.      */
  2228.     protected function configureDefaultFilterValues(array &$filterValues): void
  2229.     {
  2230.     }
  2232.     /**
  2233.      * Configures a list of form options.
  2234.      *
  2235.      * @param array<string, mixed> $formOptions
  2236.      */
  2237.     protected function configureFormOptions(array &$formOptions): void
  2238.     {
  2239.     }
  2241.     /**
  2242.      * Configures a list of default sort values.
  2243.      *
  2244.      * Example:
  2245.      *   $sortValues[DatagridInterface::SORT_BY] = 'foo'
  2246.      *   $sortValues[DatagridInterface::SORT_ORDER] = 'DESC'
  2247.      *
  2248.      * @param array<string, string|int> $sortValues
  2249.      *
  2250.      * @phpstan-param array{
  2251.      *     _page?: int,
  2252.      *     _per_page?: int,
  2253.      *     _sort_by?: string,
  2254.      *     _sort_order?: string
  2255.      * } $sortValues
  2256.      */
  2257.     protected function configureDefaultSortValues(array &$sortValues): void
  2258.     {
  2259.     }
  2261.     /**
  2262.      * Set the parent object, if any, to the provided object.
  2263.      *
  2264.      * @phpstan-param T $object
  2265.      */
  2266.     final protected function appendParentObject(object $object): void
  2267.     {
  2268.         if ($this->isChild()) {
  2269.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2271.             if (null !== $parentAssociationMapping) {
  2272.                 $parentAdmin = $this->getParent();
  2273.                 $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2275.                 if (null !== $parentObject) {
  2276.                     $propertyAccessor = PropertyAccess::createPropertyAccessor();
  2278.                     try {
  2279.                         $value = $propertyAccessor->getValue($object, $parentAssociationMapping);
  2280.                     } catch (AccessException $e) {
  2281.                         // @todo: Catching and checking AccessException here as BC for symfony/property-access < 5.1.
  2282.                         //        Catch UninitializedPropertyException and remove the check when dropping support < 5.1
  2283.                         if (AccessException::class !== \get_class($e) && !$e instanceof UninitializedPropertyException) {
  2284.                             throw $e; // Re-throw. We only want to "ignore" pure AccessException (Sf < 5.1) and UninitializedPropertyException (Sf >= 5.1)
  2285.                         }
  2286.                         $value = null;
  2287.                     }
  2289.                     if (\is_array($value) || $value instanceof \ArrayAccess) {
  2290.                         $value[] = $parentObject;
  2291.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $value);
  2292.                     } else {
  2293.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $parentObject);
  2294.                     }
  2295.                 }
  2297.                 return;
  2298.             }
  2299.         }
  2301.         if ($this->hasParentFieldDescription()) {
  2302.             $parentAdmin = $this->getParentFieldDescription()->getAdmin();
  2303.             $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2305.             if (null !== $parentObject) {
  2306.                 ObjectManipulator::setObject($object, $parentObject, $this->getParentFieldDescription());
  2307.             }
  2308.         }
  2309.     }
  2311.     /**
  2312.      * @return array<string, array<string, mixed>>
  2313.      *
  2314.      * @phpstan-param T|null $object
  2315.      */
  2316.     private function getDefaultActionButtons(string $action, ?object $object = null): array
  2317.     {
  2318.         // nothing to do for non-internal actions
  2319.         if (!isset(self::INTERNAL_ACTIONS[$action])) {
  2320.             return [];
  2321.         }
  2323.         $buttonList = [];
  2325.         $actionBit = self::INTERNAL_ACTIONS[$action];
  2327.         if (0 !== (self::MASK_OF_ACTION_CREATE & $actionBit)
  2328.             && $this->hasRoute('create')
  2329.             && $this->hasAccess('create')
  2330.         ) {
  2331.             $buttonList['create'] = [
  2332.                 'template' => $this->getTemplateRegistry()->getTemplate('button_create'),
  2333.             ];
  2334.         }
  2336.         $canAccessObject = 0 !== (self::MASK_OF_ACTIONS_USING_OBJECT & $actionBit)
  2337.             && null !== $object
  2338.             && null !== $this->id($object);
  2340.         if ($canAccessObject
  2341.             && 0 !== (self::MASK_OF_ACTION_EDIT & $actionBit)
  2342.             && $this->hasRoute('edit')
  2343.             && $this->hasAccess('edit', $object)
  2344.         ) {
  2345.             $buttonList['edit'] = [
  2346.                 'template' => $this->getTemplateRegistry()->getTemplate('button_edit'),
  2347.             ];
  2348.         }
  2350.         if ($canAccessObject
  2351.             && 0 !== (self::MASK_OF_ACTION_HISTORY & $actionBit)
  2352.             && $this->hasRoute('history')
  2353.             && $this->hasAccess('history', $object)
  2354.         ) {
  2355.             $buttonList['history'] = [
  2356.                 'template' => $this->getTemplateRegistry()->getTemplate('button_history'),
  2357.             ];
  2358.         }
  2360.         if ($canAccessObject
  2361.             && 0 !== (self::MASK_OF_ACTION_ACL & $actionBit)
  2362.             && $this->isAclEnabled()
  2363.             && $this->hasRoute('acl')
  2364.             && $this->hasAccess('acl', $object)
  2365.         ) {
  2366.             $buttonList['acl'] = [
  2367.                 'template' => $this->getTemplateRegistry()->getTemplate('button_acl'),
  2368.             ];
  2369.         }
  2371.         if ($canAccessObject
  2372.             && 0 !== (self::MASK_OF_ACTION_SHOW & $actionBit)
  2373.             && $this->hasRoute('show')
  2374.             && $this->hasAccess('show', $object)
  2375.             && \count($this->getShow()) > 0
  2376.         ) {
  2377.             $buttonList['show'] = [
  2378.                 'template' => $this->getTemplateRegistry()->getTemplate('button_show'),
  2379.             ];
  2380.         }
  2382.         if (0 !== (self::MASK_OF_ACTION_LIST & $actionBit)
  2383.             && $this->hasRoute('list')
  2384.             && $this->hasAccess('list')
  2385.         ) {
  2386.             $buttonList['list'] = [
  2387.                 'template' => $this->getTemplateRegistry()->getTemplate('button_list'),
  2388.             ];
  2389.         }
  2391.         return $buttonList;
  2392.     }
  2394.     /**
  2395.      * @return DatagridInterface<ProxyQueryInterface<T>>|null
  2396.      */
  2397.     private function buildDatagrid(): ?DatagridInterface
  2398.     {
  2399.         if ($this->loaded['datagrid']) {
  2400.             return $this->datagrid;
  2401.         }
  2403.         $this->loaded['datagrid'] = true;
  2405.         $filterParameters = $this->getFilterParameters();
  2407.         // transform DatagridInterface::SORT_BY filter parameter from a string to a FieldDescriptionInterface for the datagrid.
  2408.         if (isset($filterParameters[DatagridInterface::SORT_BY]) && \is_string($filterParameters[DatagridInterface::SORT_BY])) {
  2409.             if ($this->hasListFieldDescription($filterParameters[DatagridInterface::SORT_BY])) {
  2410.                 $filterParameters[DatagridInterface::SORT_BY] = $this->getListFieldDescription($filterParameters[DatagridInterface::SORT_BY]);
  2411.             } else {
  2412.                 $filterParameters[DatagridInterface::SORT_BY] = $this->createFieldDescription(
  2413.                     $filterParameters[DatagridInterface::SORT_BY]
  2414.                 );
  2416.                 $this->getListBuilder()->buildField(null, $filterParameters[DatagridInterface::SORT_BY]);
  2417.             }
  2418.         }
  2420.         // initialize the datagrid
  2421.         $this->datagrid = $this->getDatagridBuilder()->getBaseDatagrid($this, $filterParameters);
  2423.         $this->datagrid->getPager()->setMaxPageLinks($this->getMaxPageLinks());
  2425.         /** @psalm-suppress InvalidArgument https://github.com/vimeo/psalm/issues/8423 */
  2426.         $mapper = new DatagridMapper($this->getDatagridBuilder(), $this->datagrid, $this);
  2428.         // build the datagrid filter
  2429.         $this->configureDatagridFilters($mapper);
  2431.         // ok, try to limit to add parent filter
  2432.         if ($this->isChild()) {
  2433.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2435.             if (null !== $parentAssociationMapping && !$mapper->has($parentAssociationMapping)) {
  2436.                 $mapper->add($parentAssociationMapping, null, [
  2437.                     'show_filter' => false,
  2438.                     'label' => false,
  2439.                     'field_type' => ModelHiddenType::class,
  2440.                     'field_options' => [
  2441.                         'model_manager' => $this->getParent()->getModelManager(),
  2442.                         'class' => $this->getParent()->getClass(),
  2443.                     ],
  2444.                     'operator_type' => HiddenType::class,
  2445.                 ], [
  2446.                     'admin_code' => $this->getParent()->getCode(),
  2447.                 ]);
  2448.             }
  2449.         }
  2451.         foreach ($this->getExtensions() as $extension) {
  2452.             $extension->configureDatagridFilters($mapper);
  2453.         }
  2455.         return $this->datagrid;
  2456.     }
  2458.     /**
  2459.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2460.      */
  2461.     private function buildShow(): ?FieldDescriptionCollection
  2462.     {
  2463.         if ($this->loaded['show']) {
  2464.             return $this->show;
  2465.         }
  2467.         $this->loaded['show'] = true;
  2469.         $this->show = $this->getShowBuilder()->getBaseList();
  2470.         $mapper = new ShowMapper($this->getShowBuilder(), $this->show, $this);
  2472.         $this->configureShowFields($mapper);
  2474.         foreach ($this->getExtensions() as $extension) {
  2475.             $extension->configureShowFields($mapper);
  2476.         }
  2478.         return $this->show;
  2479.     }
  2481.     /**
  2482.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2483.      */
  2484.     private function buildList(): ?FieldDescriptionCollection
  2485.     {
  2486.         if ($this->loaded['list']) {
  2487.             return $this->list;
  2488.         }
  2490.         $this->loaded['list'] = true;
  2492.         $this->list = $this->getListBuilder()->getBaseList();
  2493.         $mapper = new ListMapper($this->getListBuilder(), $this->list, $this);
  2495.         if (\count($this->getBatchActions()) > 0 && $this->hasRequest() && !$this->getRequest()->isXmlHttpRequest()) {
  2496.             $mapper->add(ListMapper::NAME_BATCH, ListMapper::TYPE_BATCH, [
  2497.                 'label' => 'batch',
  2498.                 'sortable' => false,
  2499.                 'virtual_field' => true,
  2500.                 'template' => $this->getTemplateRegistry()->getTemplate('batch'),
  2501.             ]);
  2502.         }
  2504.         $this->configureListFields($mapper);
  2506.         foreach ($this->getExtensions() as $extension) {
  2507.             $extension->configureListFields($mapper);
  2508.         }
  2510.         if ($this->hasRequest()
  2511.             && $this->getRequest()->isXmlHttpRequest()
  2512.             && $this->getRequest()->query->getBoolean('select', true) // NEXT_MAJOR: Change the default value to `false` in version 5
  2513.         ) {
  2514.             $mapper->add(ListMapper::NAME_SELECT, ListMapper::TYPE_SELECT, [
  2515.                 'label' => false,
  2516.                 'sortable' => false,
  2517.                 'virtual_field' => false,
  2518.                 'template' => $this->getTemplateRegistry()->getTemplate('select'),
  2519.             ]);
  2520.         }
  2522.         return $this->list;
  2523.     }
  2525.     private function buildForm(): ?FormInterface
  2526.     {
  2527.         if ($this->loaded['form']) {
  2528.             return $this->form;
  2529.         }
  2531.         $this->loaded['form'] = true;
  2533.         $formBuilder = $this->getFormBuilder();
  2534.         $formBuilder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event): void {
  2535.             /** @phpstan-var T $data */
  2536.             $data = $event->getData();
  2537.             $this->preValidate($data);
  2538.         }, 100);
  2540.         $this->form = $formBuilder->getForm();
  2542.         return $this->form;
  2543.     }
  2545.     private function buildRoutes(): ?RouteCollectionInterface
  2546.     {
  2547.         if ($this->loaded['routes']) {
  2548.             return $this->routes;
  2549.         }
  2551.         $this->loaded['routes'] = true;
  2553.         $routes = new RouteCollection(
  2554.             $this->getBaseCodeRoute(),
  2555.             $this->getBaseRouteName(),
  2556.             $this->getBaseRoutePattern(),
  2557.             $this->getBaseControllerName()
  2558.         );
  2560.         $this->getRouteBuilder()->build($this, $routes);
  2562.         $this->configureRoutes($routes);
  2564.         foreach ($this->getExtensions() as $extension) {
  2565.             $extension->configureRoutes($this, $routes);
  2566.         }
  2568.         $this->routes = $routes;
  2570.         return $this->routes;
  2571.     }
  2573.     /**
  2574.      * @phpstan-template TChild of object
  2575.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2576.      */
  2577.     private function buildTabMenu(string $action, ?AdminInterface $childAdmin = null): ?ItemInterface
  2578.     {
  2579.         if ($this->loaded['tab_menu']) {
  2580.             return $this->menu;
  2581.         }
  2583.         $this->loaded['tab_menu'] = true;
  2585.         $menu = $this->getMenuFactory()->createItem('root');
  2586.         $menu->setChildrenAttribute('class', 'nav navbar-nav');
  2587.         $menu->setExtra('translation_domain', $this->getTranslationDomain());
  2589.         $this->configureTabMenu($menu, $action, $childAdmin);
  2591.         foreach ($this->getExtensions() as $extension) {
  2592.             $extension->configureTabMenu($this, $menu, $action, $childAdmin);
  2593.         }
  2595.         $this->menu = $menu;
  2597.         return $this->menu;
  2598.     }
  2599. }