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

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\Request;
  45. use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
  46. use Symfony\Component\PropertyAccess\PropertyAccess;
  47. use Symfony\Component\Routing\Generator\UrlGeneratorInterface as RoutingUrlGeneratorInterface;
  48. use Symfony\Component\Security\Acl\Model\DomainObjectInterface;
  49. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  51. /**
  52.  * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
  53.  *
  54.  * @phpstan-template T of object
  55.  * @phpstan-extends AbstractTaggedAdmin<T>
  56.  * @phpstan-implements AdminInterface<T>
  57.  */
  58. abstract class AbstractAdmin extends AbstractTaggedAdmin implements AdminInterface, DomainObjectInterface, AdminTreeInterface
  59. {
  60.     // NEXT_MAJOR: Remove the CONTEXT constants.
  61.     /** @deprecated */
  62.     public const CONTEXT_MENU = 'menu';
  63.     /** @deprecated */
  64.     public const CONTEXT_DASHBOARD = 'dashboard';
  66.     public const CLASS_REGEX =
  67.         '@
  68.         (?:([A-Za-z0-9]*)\\\)?        # vendor name / app name
  69.         (Bundle\\\)?                  # optional bundle directory
  70.         ([A-Za-z0-9]+?)(?:Bundle)?\\\ # bundle name, with optional suffix
  71.         (
  72.             Entity|Document|Model|PHPCR|CouchDocument|Phpcr|
  73.             Doctrine\\\Orm|Doctrine\\\Phpcr|Doctrine\\\MongoDB|Doctrine\\\CouchDB
  74.         )\\\(.*)@x';
  76.     private const ACTION_TREE = 1;
  77.     private const ACTION_SHOW = 2;
  78.     private const ACTION_EDIT = 4;
  79.     private const ACTION_DELETE = 8;
  80.     private const ACTION_ACL = 16;
  81.     private const ACTION_HISTORY = 32;
  82.     private const ACTION_LIST = 64;
  83.     private const ACTION_BATCH = 128;
  84.     private const INTERNAL_ACTIONS = [
  85.         'tree' => self::ACTION_TREE,
  86.         'show' => self::ACTION_SHOW,
  87.         'edit' => self::ACTION_EDIT,
  88.         'delete' => self::ACTION_DELETE,
  89.         'acl' => self::ACTION_ACL,
  90.         'history' => self::ACTION_HISTORY,
  91.         'list' => self::ACTION_LIST,
  92.         'batch' => self::ACTION_BATCH,
  93.     ];
  94.     private const MASK_OF_ACTION_CREATE = self::ACTION_TREE | self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_LIST | self::ACTION_BATCH;
  95.     private const MASK_OF_ACTION_SHOW = self::ACTION_EDIT | self::ACTION_HISTORY | self::ACTION_ACL;
  96.     private const MASK_OF_ACTION_EDIT = self::ACTION_SHOW | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_HISTORY;
  97.     private const MASK_OF_ACTION_HISTORY = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_ACL;
  98.     private const MASK_OF_ACTION_ACL = self::ACTION_EDIT | self::ACTION_HISTORY;
  99.     private const MASK_OF_ACTION_LIST = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_BATCH;
  100.     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;
  102.     private const DEFAULT_LIST_PER_PAGE_RESULTS = 25;
  103.     private const DEFAULT_LIST_PER_PAGE_OPTIONS = [10, 25, 50, 100, 250];
  105.     /**
  106.      * @deprecated since sonata-project/admin-bundle 4.15, will be removed in 5.0.
  107.      *
  108.      * The base route name used to generate the routing information.
  109.      *
  110.      * @var string|null
  111.      */
  112.     protected $baseRouteName;
  114.     /**
  115.      * @deprecated since sonata-project/admin-bundle 4.15, will be removed in 5.0.
  116.      *
  117.      * The base route pattern used to generate the routing information.
  118.      *
  119.      * @var string|null
  120.      */
  121.     protected $baseRoutePattern;
  123.     /**
  124.      * The label class name  (used in the title/breadcrumb ...).
  125.      *
  126.      * @var string|null
  127.      */
  128.     protected $classnameLabel;
  130.     /**
  131.      * Setting to true will enable preview mode for
  132.      * the entity and show a preview button in the
  133.      * edit/create forms.
  134.      *
  135.      * @var bool
  136.      */
  137.     protected $supportsPreviewMode = false;
  139.     /**
  140.      * The list FieldDescription constructed from the configureListField method.
  141.      *
  142.      * @var array<string, FieldDescriptionInterface>
  143.      */
  144.     private array $listFieldDescriptions = [];
  146.     /**
  147.      * The show FieldDescription constructed from the configureShowFields method.
  148.      *
  149.      * @var FieldDescriptionInterface[]
  150.      */
  151.     private array $showFieldDescriptions = [];
  153.     /**
  154.      * The list FieldDescription constructed from the configureFormField method.
  155.      *
  156.      * @var FieldDescriptionInterface[]
  157.      */
  158.     private array $formFieldDescriptions = [];
  160.     /**
  161.      * The filter FieldDescription constructed from the configureFilterField method.
  162.      *
  163.      * @var FieldDescriptionInterface[]
  164.      */
  165.     private array $filterFieldDescriptions = [];
  167.     /**
  168.      * The maximum number of page numbers to display in the list.
  169.      */
  170.     private int $maxPageLinks = 25;
  172.     /**
  173.      * The translation domain to be used to translate messages.
  174.      */
  175.     private string $translationDomain = 'messages';
  177.     /**
  178.      * Array of routes related to this admin.
  179.      */
  180.     private ?RouteCollectionInterface $routes = null;
  182.     /**
  183.      * The subject only set in edit/update/create mode.
  184.      *
  185.      * @phpstan-var T|null
  186.      */
  187.     private ?object $subject = null;
  189.     /**
  190.      * Define a Collection of child admin, ie /admin/order/{id}/order-element/{childId}.
  191.      *
  192.      * @var array<string, AdminInterface<object>>
  193.      */
  194.     private array $children = [];
  196.     /**
  197.      * Reference the parent admin.
  198.      *
  199.      * @var AdminInterface<object>|null
  200.      */
  201.     private ?AdminInterface $parent = null;
  203.     /**
  204.      * Reference the parent FieldDescription related to this admin
  205.      * only set for FieldDescription which is associated to an Sub Admin instance.
  206.      */
  207.     private ?FieldDescriptionInterface $parentFieldDescription = null;
  209.     /**
  210.      * If true then the current admin is part of the nested admin set (from the url).
  211.      */
  212.     private bool $currentChild = false;
  214.     /**
  215.      * The uniqId is used to avoid clashing with 2 admin related to the code
  216.      * ie: a Block linked to a Block.
  217.      */
  218.     private ?string $uniqId = null;
  220.     /**
  221.      * The current request object.
  222.      */
  223.     private ?Request $request = null;
  225.     /**
  226.      * @phpstan-var DatagridInterface<ProxyQueryInterface<T>>|null
  227.      */
  228.     private ?DatagridInterface $datagrid = null;
  230.     private ?ItemInterface $menu = null;
  232.     /**
  233.      * @var string[]
  234.      */
  235.     private array $formTheme = [];
  237.     /**
  238.      * @var string[]
  239.      */
  240.     private array $filterTheme = [];
  242.     /**
  243.      * @var AdminExtensionInterface[]
  244.      *
  245.      * @phpstan-var array<AdminExtensionInterface<T>>
  246.      */
  247.     private array $extensions = [];
  249.     /**
  250.      * @var array<string, bool>
  251.      */
  252.     private array $cacheIsGranted = [];
  254.     /**
  255.      * @var array<string, string|null>
  256.      */
  257.     private array $parentAssociationMapping = [];
  259.     /**
  260.      * The subclasses supported by the admin class.
  261.      *
  262.      * @var string[]
  263.      *
  264.      * @phpstan-var array<string, class-string<T>>
  265.      */
  266.     private array $subClasses = [];
  268.     /**
  269.      * The list collection.
  270.      *
  271.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  272.      */
  273.     private ?FieldDescriptionCollection $list = null;
  275.     /**
  276.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  277.      */
  278.     private ?FieldDescriptionCollection $show = null;
  280.     private ?FormInterface $form = null;
  282.     /**
  283.      * The cached base route name.
  284.      */
  285.     private ?string $cachedBaseRouteName = null;
  287.     /**
  288.      * The cached base route pattern.
  289.      */
  290.     private ?string $cachedBaseRoutePattern = null;
  292.     /**
  293.      * The form group disposition.
  294.      *
  295.      * @var array<string, array<string, mixed>>
  296.      */
  297.     private array $formGroups = [];
  299.     /**
  300.      * The form tabs disposition.
  301.      *
  302.      * @var array<string, array<string, mixed>>
  303.      */
  304.     private array $formTabs = [];
  306.     /**
  307.      * The view group disposition.
  308.      *
  309.      * @var array<string, array<string, mixed>>
  310.      */
  311.     private array $showGroups = [];
  313.     /**
  314.      * The view tab disposition.
  315.      *
  316.      * @var array<string, array<string, mixed>>
  317.      */
  318.     private array $showTabs = [];
  320.     /**
  321.      * @var array<string, bool>
  322.      */
  323.     private array $loaded = [
  324.         'routes' => false,
  325.         'tab_menu' => false,
  326.         'show' => false,
  327.         'list' => false,
  328.         'form' => false,
  329.         'datagrid' => false,
  330.     ];
  332.     public function getExportFormats(): array
  333.     {
  334.         return [];
  335.     }
  337.     final public function getExportFields(): array
  338.     {
  339.         $fields = $this->configureExportFields();
  341.         foreach ($this->getExtensions() as $extension) {
  342.             $fields = $extension->configureExportFields($this, $fields);
  343.         }
  345.         return $fields;
  346.     }
  348.     final public function getDataSourceIterator(): \Iterator
  349.     {
  350.         $datagrid = $this->getDatagrid();
  351.         $datagrid->buildPager();
  353.         $fields = [];
  355.         foreach ($this->getExportFields() as $key => $field) {
  356.             if (!\is_string($key)) {
  357.                 $label = $this->getTranslationLabel($field, 'export', 'label');
  358.                 $key = $this->getTranslator()->trans($label, [], $this->getTranslationDomain());
  359.             }
  361.             $fields[$key] = $field;
  362.         }
  364.         $query = $datagrid->getQuery();
  366.         return $this->getDataSource()->createIterator($query, $fields);
  367.     }
  369.     final public function initialize(): void
  370.     {
  371.         if (null === $this->classnameLabel) {
  372.             $namespaceSeparatorPos = strrpos($this->getClass(), '\\');
  373.             $this->classnameLabel = false !== $namespaceSeparatorPos
  374.                 ? substr($this->getClass(), $namespaceSeparatorPos + 1)
  375.                 : $this->getClass();
  376.         }
  378.         $this->configure();
  380.         foreach ($this->getExtensions() as $extension) {
  381.             $extension->configure($this);
  382.         }
  383.     }
  385.     final public function update(object $object): object
  386.     {
  387.         $this->preUpdate($object);
  388.         foreach ($this->getExtensions() as $extension) {
  389.             $extension->preUpdate($this, $object);
  390.         }
  392.         $this->getModelManager()->update($object);
  394.         $this->postUpdate($object);
  395.         foreach ($this->getExtensions() as $extension) {
  396.             $extension->postUpdate($this, $object);
  397.         }
  399.         return $object;
  400.     }
  402.     final public function create(object $object): object
  403.     {
  404.         $this->prePersist($object);
  405.         foreach ($this->getExtensions() as $extension) {
  406.             $extension->prePersist($this, $object);
  407.         }
  409.         $this->getModelManager()->create($object);
  411.         $this->postPersist($object);
  412.         foreach ($this->getExtensions() as $extension) {
  413.             $extension->postPersist($this, $object);
  414.         }
  416.         $this->createObjectSecurity($object);
  418.         return $object;
  419.     }
  421.     final public function delete(object $object): void
  422.     {
  423.         $this->preRemove($object);
  424.         foreach ($this->getExtensions() as $extension) {
  425.             $extension->preRemove($this, $object);
  426.         }
  428.         $this->getSecurityHandler()->deleteObjectSecurity($this, $object);
  429.         $this->getModelManager()->delete($object);
  431.         $this->postRemove($object);
  432.         foreach ($this->getExtensions() as $extension) {
  433.             $extension->postRemove($this, $object);
  434.         }
  435.     }
  437.     public function preBatchAction(string $actionName, ProxyQueryInterface $query, array &$idx, bool $allElements = false): void
  438.     {
  439.     }
  441.     final public function getDefaultFilterParameters(): array
  442.     {
  443.         return array_merge(
  444.             $this->getDefaultSortValues(),
  445.             $this->getDefaultFilterValues()
  446.         );
  447.     }
  449.     final public function getFilterParameters(): array
  450.     {
  451.         $parameters = $this->getDefaultFilterParameters();
  453.         // build the values array
  454.         if ($this->hasRequest()) {
  455.             $bag = $this->getRequest()->query;
  456.             $filters = $bag->all('filter');
  458.             if (isset($filters[DatagridInterface::PAGE])) {
  459.                 $filters[DatagridInterface::PAGE] = (int) $filters[DatagridInterface::PAGE];
  460.             }
  461.             if (isset($filters[DatagridInterface::PER_PAGE])) {
  462.                 $filters[DatagridInterface::PER_PAGE] = (int) $filters[DatagridInterface::PER_PAGE];
  463.             }
  465.             // if filter persistence is configured
  466.             if ($this->hasFilterPersister()) {
  467.                 // if reset filters is asked, remove from storage
  468.                 if ('reset' === $this->getRequest()->query->get('filters')) {
  469.                     $this->getFilterPersister()->reset($this->getCode());
  470.                 }
  472.                 // if no filters, fetch from storage
  473.                 // otherwise save to storage
  474.                 if ([] === $filters) {
  475.                     $filters = $this->getFilterPersister()->get($this->getCode());
  476.                 } else {
  477.                     $this->getFilterPersister()->set($this->getCode(), $filters);
  478.                 }
  479.             }
  481.             $parameters = ParametersManipulator::merge($parameters, $filters);
  483.             // always force the parent value
  484.             if ($this->isChild()) {
  485.                 $parentAssociationMapping = $this->getParentAssociationMapping();
  486.                 if (null !== $parentAssociationMapping) {
  487.                     $name = str_replace('.', '__', $parentAssociationMapping);
  488.                     $parameters[$name] = ['value' => $this->getRequest()->get($this->getParent()->getIdParameter())];
  489.                 }
  490.             }
  491.         }
  493.         if (
  494.             !isset($parameters[DatagridInterface::PER_PAGE])
  495.             || !\is_int($parameters[DatagridInterface::PER_PAGE])
  496.             || !$this->determinedPerPageValue($parameters[DatagridInterface::PER_PAGE])
  497.         ) {
  498.             $parameters[DatagridInterface::PER_PAGE] = $this->getMaxPerPage();
  499.         }
  501.         $parameters = $this->configureFilterParameters($parameters);
  503.         foreach ($this->getExtensions() as $extension) {
  504.             $parameters = $extension->configureFilterParameters($this, $parameters);
  505.         }
  507.         return $parameters;
  508.     }
  510.     /**
  511.      * Returns the name of the parent related field, so the field can be use to set the default
  512.      * value (ie the parent object) or to filter the object.
  513.      *
  514.      * @throws \LogicException
  515.      */
  516.     final public function getParentAssociationMapping(): ?string
  517.     {
  518.         if (!$this->isChild()) {
  519.             throw new \LogicException(sprintf(
  520.                 'Admin "%s" has no parent.',
  521.                 static::class
  522.             ));
  523.         }
  525.         $parent = $this->getParent()->getCode();
  527.         return $this->parentAssociationMapping[$parent];
  528.     }
  530.     final public function getBaseRoutePattern(): string
  531.     {
  532.         if (null !== $this->cachedBaseRoutePattern) {
  533.             return $this->cachedBaseRoutePattern;
  534.         }
  536.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route pattern
  537.             $this->cachedBaseRoutePattern = sprintf(
  538.                 '%s/%s/%s',
  539.                 $this->getParent()->getBaseRoutePattern(),
  540.                 $this->getParent()->getRouterIdParameter(),
  541.                 $this->generateBaseRoutePattern(true)
  542.             );
  543.         } else {
  544.             $this->cachedBaseRoutePattern = $this->generateBaseRoutePattern();
  545.         }
  547.         return $this->cachedBaseRoutePattern;
  548.     }
  550.     /**
  551.      * Returns the baseRouteName used to generate the routing information.
  552.      *
  553.      * @return string the baseRouteName used to generate the routing information
  554.      */
  555.     final public function getBaseRouteName(): string
  556.     {
  557.         if (null !== $this->cachedBaseRouteName) {
  558.             return $this->cachedBaseRouteName;
  559.         }
  561.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route name
  562.             $this->cachedBaseRouteName = sprintf(
  563.                 '%s_%s',
  564.                 $this->getParent()->getBaseRouteName(),
  565.                 $this->generateBaseRouteName(true)
  566.             );
  567.         } else {
  568.             $this->cachedBaseRouteName = $this->generateBaseRouteName();
  569.         }
  571.         return $this->cachedBaseRouteName;
  572.     }
  574.     final public function getClass(): string
  575.     {
  576.         if ($this->hasActiveSubClass()) {
  577.             if ($this->hasParentFieldDescription()) {
  578.                 throw new \LogicException('Feature not implemented: an embedded admin cannot have subclass');
  579.             }
  581.             $subClass = $this->getRequest()->query->get('subclass');
  582.             \assert(\is_string($subClass));
  584.             if (!$this->hasSubClass($subClass)) {
  585.                 throw new \LogicException(sprintf('Subclass "%s" is not defined.', $subClass));
  586.             }
  588.             return $this->getSubClass($subClass);
  589.         }
  591.         // Do not use `$this->hasSubject()` and `$this->getSubject()` here to avoid infinite loop.
  592.         // `getSubject` use `hasSubject()` which use `getObject()` which use `getClass()`.
  593.         if (null !== $this->subject) {
  594.             $modelManager = $this->getModelManager();
  595.             /** @phpstan-var class-string<T> $class */
  596.             $class = $modelManager instanceof ProxyResolverInterface
  597.                 ? $modelManager->getRealClass($this->subject)
  598.                 // NEXT_MAJOR: Change to `\get_class($this->subject)` instead
  599.                 : BCHelper::getClass($this->subject);
  601.             return $class;
  602.         }
  604.         return $this->getModelClass();
  605.     }
  607.     final public function getSubClasses(): array
  608.     {
  609.         return $this->subClasses;
  610.     }
  612.     final public function setSubClasses(array $subClasses): void
  613.     {
  614.         $this->subClasses = $subClasses;
  615.     }
  617.     final public function hasSubClass(string $name): bool
  618.     {
  619.         return isset($this->subClasses[$name]);
  620.     }
  622.     final public function hasActiveSubClass(): bool
  623.     {
  624.         if (\count($this->subClasses) > 0 && $this->hasRequest()) {
  625.             return \is_string($this->getRequest()->query->get('subclass'));
  626.         }
  628.         return false;
  629.     }
  631.     final public function getActiveSubClass(): string
  632.     {
  633.         if (!$this->hasActiveSubClass()) {
  634.             throw new \LogicException(sprintf(
  635.                 'Admin "%s" has no active subclass.',
  636.                 static::class
  637.             ));
  638.         }
  640.         return $this->getSubClass($this->getActiveSubclassCode());
  641.     }
  643.     final public function getActiveSubclassCode(): string
  644.     {
  645.         if (!$this->hasActiveSubClass()) {
  646.             throw new \LogicException(sprintf(
  647.                 'Admin "%s" has no active subclass.',
  648.                 static::class
  649.             ));
  650.         }
  652.         $subClass = (string) $this->getRequest()->query->get('subclass');
  654.         if (!$this->hasSubClass($subClass)) {
  655.             throw new \LogicException(sprintf(
  656.                 'Admin "%s" has no active subclass.',
  657.                 static::class
  658.             ));
  659.         }
  661.         return $subClass;
  662.     }
  664.     final public function getBatchActions(): array
  665.     {
  666.         if (!$this->hasRoute('batch')) {
  667.             return [];
  668.         }
  670.         $actions = [];
  672.         if ($this->hasRoute('delete') && $this->hasAccess('delete')) {
  673.             $actions['delete'] = [
  674.                 'label' => 'action_delete',
  675.                 'translation_domain' => 'SonataAdminBundle',
  676.                 'ask_confirmation' => true, // by default always true
  677.             ];
  678.         }
  680.         $actions = $this->configureBatchActions($actions);
  682.         foreach ($this->getExtensions() as $extension) {
  683.             $actions = $extension->configureBatchActions($this, $actions);
  684.         }
  686.         foreach ($actions as $name => &$action) {
  687.             if (!\array_key_exists('label', $action)) {
  688.                 $action['label'] = $this->getTranslationLabel($name, 'batch', 'label');
  689.             }
  691.             if (!\array_key_exists('translation_domain', $action)) {
  692.                 $action['translation_domain'] = $this->getTranslationDomain();
  693.             }
  694.         }
  696.         return $actions;
  697.     }
  699.     final public function getRoutes(): RouteCollectionInterface
  700.     {
  701.         $routes = $this->buildRoutes();
  702.         if (null === $routes) {
  703.             throw new \LogicException('Cannot access routes during the building process.');
  704.         }
  706.         return $routes;
  707.     }
  709.     public function getRouterIdParameter(): string
  710.     {
  711.         return sprintf('{%s}', $this->getIdParameter());
  712.     }
  714.     public function getIdParameter(): string
  715.     {
  716.         $parameter = 'id';
  718.         for ($i = 0; $i < $this->getChildDepth(); ++$i) {
  719.             $parameter = sprintf('child%s', ucfirst($parameter));
  720.         }
  722.         return $parameter;
  723.     }
  725.     final public function hasRoute(string $name): bool
  726.     {
  727.         return $this->getRouteGenerator()->hasAdminRoute($this, $name);
  728.     }
  730.     final public function isCurrentRoute(string $name, ?string $adminCode = null): bool
  731.     {
  732.         if (!$this->hasRequest()) {
  733.             return false;
  734.         }
  736.         $request = $this->getRequest();
  737.         $route = $request->get('_route');
  739.         if (null !== $adminCode) {
  740.             $pool = $this->getConfigurationPool();
  742.             if ($pool->hasAdminByAdminCode($adminCode)) {
  743.                 $admin = $pool->getAdminByAdminCode($adminCode);
  744.             } else {
  745.                 return false;
  746.             }
  747.         } else {
  748.             $admin = $this;
  749.         }
  751.         return $admin->getRoutes()->getRouteName($name) === $route;
  752.     }
  754.     final public function generateObjectUrl(string $name, object $object, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  755.     {
  756.         $parameters[$this->getIdParameter()] = $this->getUrlSafeIdentifier($object);
  758.         return $this->generateUrl($name, $parameters, $referenceType);
  759.     }
  761.     final public function generateUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  762.     {
  763.         return $this->getRouteGenerator()->generateUrl($this, $name, $parameters, $referenceType);
  764.     }
  766.     final public function generateMenuUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): array
  767.     {
  768.         return $this->getRouteGenerator()->generateMenuUrl($this, $name, $parameters, $referenceType);
  769.     }
  771.     final public function getNewInstance(): object
  772.     {
  773.         $object = $this->createNewInstance();
  775.         $this->alterNewInstance($object);
  777.         foreach ($this->getExtensions() as $extension) {
  778.             $extension->alterNewInstance($this, $object);
  779.         }
  781.         return $object;
  782.     }
  784.     final public function getFormBuilder(): FormBuilderInterface
  785.     {
  786.         $formBuilder = $this->getFormContractor()->getFormBuilder(
  787.             $this->getUniqId(),
  788.             ['data_class' => $this->getClass()] + $this->getFormOptions(),
  789.         );
  791.         $this->defineFormBuilder($formBuilder);
  793.         return $formBuilder;
  794.     }
  796.     /**
  797.      * This method is being called by the main admin class and the child class,
  798.      * the getFormBuilder is only call by the main admin class.
  799.      */
  800.     final public function defineFormBuilder(FormBuilderInterface $formBuilder): void
  801.     {
  802.         if (!$this->hasSubject()) {
  803.             throw new \LogicException(sprintf(
  804.                 'Admin "%s" has no subject.',
  805.                 static::class
  806.             ));
  807.         }
  809.         $mapper = new FormMapper($this->getFormContractor(), $formBuilder, $this);
  811.         $this->configureFormFields($mapper);
  813.         foreach ($this->getExtensions() as $extension) {
  814.             $extension->configureFormFields($mapper);
  815.         }
  816.     }
  818.     final public function attachAdminClass(FieldDescriptionInterface $fieldDescription): void
  819.     {
  820.         $pool = $this->getConfigurationPool();
  822.         try {
  823.             $admin = $pool->getAdminByFieldDescription($fieldDescription);
  824.         } catch (AdminClassNotFoundException) {
  825.             // Using a fieldDescription with no admin class for the target model is a valid case.
  826.             // Since there is no easy way to check for this case, we catch the exception instead.
  827.             return;
  828.         }
  830.         if ($this->hasRequest()) {
  831.             $admin->setRequest($this->getRequest());
  832.         }
  834.         $fieldDescription->setAssociationAdmin($admin);
  835.     }
  837.     /**
  838.      * @param string|int|null $id
  839.      *
  840.      * @phpstan-return T|null
  841.      */
  842.     final public function getObject($id): ?object
  843.     {
  844.         if (null === $id) {
  845.             return null;
  846.         }
  848.         $object = $this->getModelManager()->find($this->getClass(), $id);
  849.         if (null === $object) {
  850.             return null;
  851.         }
  853.         $this->alterObject($object);
  854.         foreach ($this->getExtensions() as $extension) {
  855.             $extension->alterObject($this, $object);
  856.         }
  858.         return $object;
  859.     }
  861.     final public function getForm(): FormInterface
  862.     {
  863.         $form = $this->buildForm();
  864.         if (null === $form) {
  865.             throw new \LogicException('Cannot access form during the building process.');
  866.         }
  868.         return $form;
  869.     }
  871.     final public function getList(): FieldDescriptionCollection
  872.     {
  873.         $list = $this->buildList();
  874.         if (null === $list) {
  875.             throw new \LogicException('Cannot access list during the building process.');
  876.         }
  878.         return $list;
  879.     }
  881.     final public function createQuery(): ProxyQueryInterface
  882.     {
  883.         $query = $this->getModelManager()->createQuery($this->getClass());
  885.         $query = $this->configureQuery($query);
  886.         foreach ($this->getExtensions() as $extension) {
  887.             $extension->configureQuery($this, $query);
  888.         }
  890.         return $query;
  891.     }
  893.     final public function getDatagrid(): DatagridInterface
  894.     {
  895.         $datagrid = $this->buildDatagrid();
  896.         if (null === $datagrid) {
  897.             throw new \LogicException('Cannot access datagrid during the building process.');
  898.         }
  900.         return $datagrid;
  901.     }
  903.     final public function getSideMenu(string $action, ?AdminInterface $childAdmin = null): ItemInterface
  904.     {
  905.         if ($this->isChild()) {
  906.             return $this->getParent()->getSideMenu($action, $this);
  907.         }
  909.         $menu = $this->buildTabMenu($action, $childAdmin);
  910.         if (null === $menu) {
  911.             throw new \LogicException('Cannot access menu during the building process.');
  912.         }
  914.         return $menu;
  915.     }
  917.     final public function getRootCode(): string
  918.     {
  919.         return $this->getRoot()->getCode();
  920.     }
  922.     final public function getRoot(): AdminInterface
  923.     {
  924.         if (!$this->hasParentFieldDescription()) {
  925.             return $this;
  926.         }
  928.         return $this->getParentFieldDescription()->getAdmin()->getRoot();
  929.     }
  931.     final public function getMaxPerPage(): int
  932.     {
  933.         $sortValues = $this->getDefaultSortValues();
  935.         return $sortValues[DatagridInterface::PER_PAGE] ?? self::DEFAULT_LIST_PER_PAGE_RESULTS;
  936.     }
  938.     final public function setMaxPageLinks(int $maxPageLinks): void
  939.     {
  940.         $this->maxPageLinks = $maxPageLinks;
  941.     }
  943.     final public function getMaxPageLinks(): int
  944.     {
  945.         return $this->maxPageLinks;
  946.     }
  948.     final public function getFormGroups(): array
  949.     {
  950.         return $this->formGroups;
  951.     }
  953.     final public function setFormGroups(array $formGroups): void
  954.     {
  955.         $this->formGroups = $formGroups;
  956.     }
  958.     final public function removeFieldFromFormGroup(string $key): void
  959.     {
  960.         foreach ($this->formGroups as $name => $_formGroup) {
  961.             unset($this->formGroups[$name]['fields'][$key]);
  963.             if ([] === $this->formGroups[$name]['fields']) {
  964.                 unset($this->formGroups[$name]);
  965.             }
  966.         }
  967.     }
  969.     final public function reorderFormGroup(string $group, array $keys): void
  970.     {
  971.         $formGroups = $this->getFormGroups();
  972.         $formGroups[$group]['fields'] = array_merge(array_flip($keys), $formGroups[$group]['fields']);
  973.         $this->setFormGroups($formGroups);
  974.     }
  976.     final public function getFormTabs(): array
  977.     {
  978.         return $this->formTabs;
  979.     }
  981.     final public function setFormTabs(array $formTabs): void
  982.     {
  983.         $this->formTabs = $formTabs;
  984.     }
  986.     final public function getShowTabs(): array
  987.     {
  988.         return $this->showTabs;
  989.     }
  991.     final public function setShowTabs(array $showTabs): void
  992.     {
  993.         $this->showTabs = $showTabs;
  994.     }
  996.     final public function getShowGroups(): array
  997.     {
  998.         return $this->showGroups;
  999.     }
  1001.     final public function setShowGroups(array $showGroups): void
  1002.     {
  1003.         $this->showGroups = $showGroups;
  1004.     }
  1006.     final public function removeFieldFromShowGroup(string $key): void
  1007.     {
  1008.         foreach ($this->showGroups as $name => $_showGroup) {
  1009.             unset($this->showGroups[$name]['fields'][$key]);
  1011.             if ([] === $this->showGroups[$name]['fields']) {
  1012.                 unset($this->showGroups[$name]);
  1013.             }
  1014.         }
  1015.     }
  1017.     final public function reorderShowGroup(string $group, array $keys): void
  1018.     {
  1019.         $showGroups = $this->getShowGroups();
  1020.         $showGroups[$group]['fields'] = array_merge(array_flip($keys), $showGroups[$group]['fields']);
  1021.         $this->setShowGroups($showGroups);
  1022.     }
  1024.     final public function setParentFieldDescription(FieldDescriptionInterface $parentFieldDescription): void
  1025.     {
  1026.         $this->parentFieldDescription = $parentFieldDescription;
  1027.     }
  1029.     final public function getParentFieldDescription(): FieldDescriptionInterface
  1030.     {
  1031.         if (!$this->hasParentFieldDescription()) {
  1032.             throw new \LogicException(sprintf(
  1033.                 'Admin "%s" has no parent field description.',
  1034.                 static::class
  1035.             ));
  1036.         }
  1038.         return $this->parentFieldDescription;
  1039.     }
  1041.     /**
  1042.      * @phpstan-assert-if-true !null $this->parentFieldDescription
  1043.      */
  1044.     final public function hasParentFieldDescription(): bool
  1045.     {
  1046.         return null !== $this->parentFieldDescription;
  1047.     }
  1049.     final public function setSubject(?object $subject): void
  1050.     {
  1051.         if (null !== $subject && !is_a($subject, $this->getModelClass(), true)) {
  1052.             throw new \LogicException(sprintf(
  1053.                 'Admin "%s" does not allow this subject: %s, use the one register with this admin class %s',
  1054.                 static::class,
  1055.                 $subject::class,
  1056.                 $this->getModelClass()
  1057.             ));
  1058.         }
  1060.         $this->subject = $subject;
  1061.     }
  1063.     final public function getSubject(): object
  1064.     {
  1065.         if (!$this->hasSubject()) {
  1066.             throw new \LogicException(sprintf(
  1067.                 'Admin "%s" has no subject.',
  1068.                 static::class
  1069.             ));
  1070.         }
  1072.         return $this->subject;
  1073.     }
  1075.     /**
  1076.      * @phpstan-assert-if-true !null $this->subject
  1077.      */
  1078.     final public function hasSubject(): bool
  1079.     {
  1080.         if (null === $this->subject && $this->hasRequest() && !$this->hasParentFieldDescription()) {
  1081.             $id = $this->getRequest()->get($this->getIdParameter());
  1083.             if (null !== $id) {
  1084.                 $this->subject = $this->getObject($id);
  1085.             }
  1086.         }
  1088.         return null !== $this->subject;
  1089.     }
  1091.     final public function getFormFieldDescriptions(): array
  1092.     {
  1093.         $this->buildForm();
  1095.         return $this->formFieldDescriptions;
  1096.     }
  1098.     final public function getFormFieldDescription(string $name): FieldDescriptionInterface
  1099.     {
  1100.         $this->buildForm();
  1102.         if (!$this->hasFormFieldDescription($name)) {
  1103.             throw new \LogicException(sprintf(
  1104.                 'Admin "%s" has no form field description for the field %s.',
  1105.                 static::class,
  1106.                 $name
  1107.             ));
  1108.         }
  1110.         return $this->formFieldDescriptions[$name];
  1111.     }
  1113.     /**
  1114.      * Returns true if the admin has a FieldDescription with the given $name.
  1115.      */
  1116.     final public function hasFormFieldDescription(string $name): bool
  1117.     {
  1118.         $this->buildForm();
  1120.         return \array_key_exists($name, $this->formFieldDescriptions);
  1121.     }
  1123.     final public function addFormFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1124.     {
  1125.         $this->formFieldDescriptions[$name] = $fieldDescription;
  1126.     }
  1128.     /**
  1129.      * remove a FieldDescription.
  1130.      */
  1131.     final public function removeFormFieldDescription(string $name): void
  1132.     {
  1133.         unset($this->formFieldDescriptions[$name]);
  1134.     }
  1136.     /**
  1137.      * build and return the collection of form FieldDescription.
  1138.      *
  1139.      * @return FieldDescriptionInterface[] collection of form FieldDescription
  1140.      */
  1141.     final public function getShowFieldDescriptions(): array
  1142.     {
  1143.         $this->buildShow();
  1145.         return $this->showFieldDescriptions;
  1146.     }
  1148.     /**
  1149.      * Returns the form FieldDescription with the given $name.
  1150.      */
  1151.     final public function getShowFieldDescription(string $name): FieldDescriptionInterface
  1152.     {
  1153.         $this->buildShow();
  1155.         if (!$this->hasShowFieldDescription($name)) {
  1156.             throw new \LogicException(sprintf(
  1157.                 'Admin "%s" has no show field description for the field %s.',
  1158.                 static::class,
  1159.                 $name
  1160.             ));
  1161.         }
  1163.         return $this->showFieldDescriptions[$name];
  1164.     }
  1166.     final public function hasShowFieldDescription(string $name): bool
  1167.     {
  1168.         $this->buildShow();
  1170.         return \array_key_exists($name, $this->showFieldDescriptions);
  1171.     }
  1173.     final public function addShowFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1174.     {
  1175.         $this->showFieldDescriptions[$name] = $fieldDescription;
  1176.     }
  1178.     final public function removeShowFieldDescription(string $name): void
  1179.     {
  1180.         unset($this->showFieldDescriptions[$name]);
  1181.     }
  1183.     final public function getListFieldDescriptions(): array
  1184.     {
  1185.         $this->buildList();
  1187.         return $this->listFieldDescriptions;
  1188.     }
  1190.     final public function getListFieldDescription(string $name): FieldDescriptionInterface
  1191.     {
  1192.         $this->buildList();
  1194.         if (!$this->hasListFieldDescription($name)) {
  1195.             throw new \LogicException(sprintf(
  1196.                 'Admin "%s" has no list field description for %s.',
  1197.                 static::class,
  1198.                 $name
  1199.             ));
  1200.         }
  1202.         return $this->listFieldDescriptions[$name];
  1203.     }
  1205.     final public function hasListFieldDescription(string $name): bool
  1206.     {
  1207.         $this->buildList();
  1209.         return \array_key_exists($name, $this->listFieldDescriptions);
  1210.     }
  1212.     final public function addListFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1213.     {
  1214.         $this->listFieldDescriptions[$name] = $fieldDescription;
  1215.     }
  1217.     final public function removeListFieldDescription(string $name): void
  1218.     {
  1219.         unset($this->listFieldDescriptions[$name]);
  1220.     }
  1222.     final public function getFilterFieldDescription(string $name): FieldDescriptionInterface
  1223.     {
  1224.         $this->buildDatagrid();
  1226.         if (!$this->hasFilterFieldDescription($name)) {
  1227.             throw new \LogicException(sprintf(
  1228.                 'Admin "%s" has no filter field description for the field %s.',
  1229.                 static::class,
  1230.                 $name
  1231.             ));
  1232.         }
  1234.         return $this->filterFieldDescriptions[$name];
  1235.     }
  1237.     final public function hasFilterFieldDescription(string $name): bool
  1238.     {
  1239.         $this->buildDatagrid();
  1241.         return \array_key_exists($name, $this->filterFieldDescriptions);
  1242.     }
  1244.     final public function addFilterFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1245.     {
  1246.         $this->filterFieldDescriptions[$name] = $fieldDescription;
  1247.     }
  1249.     final public function removeFilterFieldDescription(string $name): void
  1250.     {
  1251.         unset($this->filterFieldDescriptions[$name]);
  1252.     }
  1254.     final public function getFilterFieldDescriptions(): array
  1255.     {
  1256.         $this->buildDatagrid();
  1258.         return $this->filterFieldDescriptions;
  1259.     }
  1261.     /**
  1262.      * @psalm-suppress PossiblyNullArgument Will be solved in NEXT_MAJOR
  1263.      */
  1264.     final public function addChild(AdminInterface $child, ?string $field = null): void
  1265.     {
  1266.         $parentAdmin = $this;
  1267.         while ($parentAdmin->isChild() && $parentAdmin->getCode() !== $child->getCode()) {
  1268.             $parentAdmin = $parentAdmin->getParent();
  1269.         }
  1271.         if ($parentAdmin->getCode() === $child->getCode()) {
  1272.             throw new \LogicException(sprintf(
  1273.                 'Circular reference detected! The child admin `%s` is already in the parent tree of the `%s` admin.',
  1274.                 $child->getCode(),
  1275.                 $this->getCode()
  1276.             ));
  1277.         }
  1279.         $this->children[$child->getCode()] = $child;
  1281.         // @phpstan-ignore-next-line Will be solved in NEXT_MAJOR
  1282.         $child->setParent($this, $field);
  1283.     }
  1285.     final public function hasChild(string $code): bool
  1286.     {
  1287.         return isset($this->children[$code]);
  1288.     }
  1290.     final public function getChildren(): array
  1291.     {
  1292.         return $this->children;
  1293.     }
  1295.     final public function getChild(string $code): AdminInterface
  1296.     {
  1297.         if (!$this->hasChild($code)) {
  1298.             throw new \LogicException(sprintf(
  1299.                 'Admin "%s" has no child for the code %s.',
  1300.                 static::class,
  1301.                 $code
  1302.             ));
  1303.         }
  1305.         return $this->getChildren()[$code];
  1306.     }
  1308.     final public function setParent(AdminInterface $parent, ?string $parentAssociationMapping = null): void
  1309.     {
  1310.         $this->parent = $parent;
  1311.         $this->parentAssociationMapping[$parent->getCode()] = $parentAssociationMapping;
  1312.     }
  1314.     final public function getParent(): AdminInterface
  1315.     {
  1316.         if (null === $this->parent) {
  1317.             throw new \LogicException(sprintf(
  1318.                 'Admin "%s" has no parent.',
  1319.                 static::class
  1320.             ));
  1321.         }
  1323.         return $this->parent;
  1324.     }
  1326.     final public function getRootAncestor(): AdminInterface
  1327.     {
  1328.         $parent = $this;
  1330.         while ($parent->isChild()) {
  1331.             $parent = $parent->getParent();
  1332.         }
  1334.         return $parent;
  1335.     }
  1337.     final public function getChildDepth(): int
  1338.     {
  1339.         $parent = $this;
  1340.         $depth = 0;
  1342.         while ($parent->isChild()) {
  1343.             $parent = $parent->getParent();
  1344.             ++$depth;
  1345.         }
  1347.         return $depth;
  1348.     }
  1350.     final public function getCurrentLeafChildAdmin(): ?AdminInterface
  1351.     {
  1352.         $child = $this->getCurrentChildAdmin();
  1354.         if (null === $child) {
  1355.             return null;
  1356.         }
  1358.         for ($c = $child; null !== $c; $c = $child->getCurrentChildAdmin()) {
  1359.             $child = $c;
  1360.         }
  1362.         return $child;
  1363.     }
  1365.     final public function isChild(): bool
  1366.     {
  1367.         return $this->parent instanceof AdminInterface;
  1368.     }
  1370.     /**
  1371.      * Returns true if the admin has children, false otherwise.
  1372.      *
  1373.      * @phpstan-assert-if-true non-empty-array $this->children
  1374.      */
  1375.     final public function hasChildren(): bool
  1376.     {
  1377.         return \count($this->children) > 0;
  1378.     }
  1380.     final public function setUniqId(string $uniqId): void
  1381.     {
  1382.         $this->uniqId = $uniqId;
  1383.     }
  1385.     final public function getUniqId(): string
  1386.     {
  1387.         if (null === $this->uniqId) {
  1388.             $this->uniqId = sprintf('s%s', uniqid());
  1389.         }
  1391.         return $this->uniqId;
  1392.     }
  1394.     final public function getClassnameLabel(): string
  1395.     {
  1396.         if (null === $this->classnameLabel) {
  1397.             throw new \LogicException(sprintf(
  1398.                 'Admin "%s" has no classname label. Did you forgot to initialize the admin ?',
  1399.                 static::class
  1400.             ));
  1401.         }
  1403.         return $this->classnameLabel;
  1404.     }
  1406.     final public function getPersistentParameters(): array
  1407.     {
  1408.         $parameters = $this->configurePersistentParameters();
  1409.         foreach ($this->getExtensions() as $extension) {
  1410.             $parameters = $extension->configurePersistentParameters($this, $parameters);
  1411.         }
  1413.         return $parameters;
  1414.     }
  1416.     final public function getPersistentParameter(string $name, $default = null)
  1417.     {
  1418.         $parameters = $this->getPersistentParameters();
  1420.         return $parameters[$name] ?? $default;
  1421.     }
  1423.     final public function setCurrentChild(bool $currentChild): void
  1424.     {
  1425.         $this->currentChild = $currentChild;
  1426.     }
  1428.     final public function isCurrentChild(): bool
  1429.     {
  1430.         return $this->currentChild;
  1431.     }
  1433.     final public function getCurrentChildAdmin(): ?AdminInterface
  1434.     {
  1435.         foreach ($this->getChildren() as $child) {
  1436.             if ($child->isCurrentChild()) {
  1437.                 return $child;
  1438.             }
  1439.         }
  1441.         return null;
  1442.     }
  1444.     final public function setTranslationDomain(string $translationDomain): void
  1445.     {
  1446.         $this->translationDomain = $translationDomain;
  1447.     }
  1449.     final public function getTranslationDomain(): string
  1450.     {
  1451.         return $this->translationDomain;
  1452.     }
  1454.     final public function getTranslationLabel(string $label, string $context = '', string $type = ''): string
  1455.     {
  1456.         return $this->getLabelTranslatorStrategy()->getLabel($label, $context, $type);
  1457.     }
  1459.     final public function setRequest(Request $request): void
  1460.     {
  1461.         $this->request = $request;
  1463.         foreach ($this->getChildren() as $children) {
  1464.             $children->setRequest($request);
  1465.         }
  1466.     }
  1468.     final public function getRequest(): Request
  1469.     {
  1470.         if (!$this->hasRequest()) {
  1471.             throw new \LogicException('The Request object has not been set');
  1472.         }
  1474.         return $this->request;
  1475.     }
  1477.     /**
  1478.      * @phpstan-assert-if-true !null $this->request
  1479.      */
  1480.     final public function hasRequest(): bool
  1481.     {
  1482.         return null !== $this->request;
  1483.     }
  1485.     final public function getBaseCodeRoute(): string
  1486.     {
  1487.         if ($this->isChild()) {
  1488.             return $this->getParent()->getBaseCodeRoute().'|'.$this->getCode();
  1489.         }
  1491.         return $this->getCode();
  1492.     }
  1494.     /**
  1495.      * @return string
  1496.      */
  1497.     public function getObjectIdentifier()
  1498.     {
  1499.         return $this->getCode();
  1500.     }
  1502.     public function showInDashboard(): bool
  1503.     {
  1504.         // NEXT_MAJOR: Remove those lines and uncomment the last one.
  1505.         $permissionShow = $this->getPermissionsShow(self::CONTEXT_DASHBOARD, 'sonata_deprecation_mute');
  1506.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1508.         return $this->isGranted($permission);
  1509.         // return $this->isGranted('LIST');
  1510.     }
  1512.     /**
  1513.      * NEXT_MAJOR: Remove this method.
  1514.      *
  1515.      * @deprecated since sonata-project/admin-bundle version 4.7 use showInDashboard instead
  1516.      */
  1517.     final public function showIn(string $context): bool
  1518.     {
  1519.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  1520.             @trigger_error(sprintf(
  1521.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  1522.                 .' removed in 5.0 version. Use showInDashboard() instead.',
  1523.                 __METHOD__
  1524.             ), \E_USER_DEPRECATED);
  1525.         }
  1527.         $permissionShow = $this->getPermissionsShow($context, 'sonata_deprecation_mute');
  1528.         // Avoid isGranted deprecation if there is only one permission show.
  1529.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1531.         return $this->isGranted($permission);
  1532.     }
  1534.     final public function createObjectSecurity(object $object): void
  1535.     {
  1536.         $this->getSecurityHandler()->createObjectSecurity($this, $object);
  1537.     }
  1539.     final public function isGranted($name, ?object $object = null): bool
  1540.     {
  1541.         if (\is_array($name)) {
  1542.             @trigger_error(
  1543.                 sprintf(
  1544.                     'Passing an array as argument 1 of "%s()" is deprecated since sonata-project/admin-bundle 4.6'
  1545.                     .' and will throw an error in 5.0. You MUST pass a string instead.',
  1546.                     __METHOD__
  1547.                 ),
  1548.                 \E_USER_DEPRECATED
  1549.             );
  1550.         }
  1552.         $objectRef = null !== $object ? sprintf('/%s#%s', spl_object_hash($object), $this->id($object) ?? '') : '';
  1553.         $key = md5(json_encode($name, \JSON_THROW_ON_ERROR).$objectRef);
  1555.         if (!\array_key_exists($key, $this->cacheIsGranted)) {
  1556.             $this->cacheIsGranted[$key] = $this->getSecurityHandler()->isGranted($this, $name, $object ?? $this);
  1557.         }
  1559.         return $this->cacheIsGranted[$key];
  1560.     }
  1562.     final public function getUrlSafeIdentifier(object $model): ?string
  1563.     {
  1564.         return $this->getModelManager()->getUrlSafeIdentifier($model);
  1565.     }
  1567.     final public function getNormalizedIdentifier(object $model): ?string
  1568.     {
  1569.         return $this->getModelManager()->getNormalizedIdentifier($model);
  1570.     }
  1572.     public function id(object $model): ?string
  1573.     {
  1574.         return $this->getNormalizedIdentifier($model);
  1575.     }
  1577.     final public function getShow(): FieldDescriptionCollection
  1578.     {
  1579.         $show = $this->buildShow();
  1580.         if (null === $show) {
  1581.             throw new \LogicException('Cannot access show during the building process.');
  1582.         }
  1584.         return $show;
  1585.     }
  1587.     final public function setFormTheme(array $formTheme): void
  1588.     {
  1589.         $this->formTheme = $formTheme;
  1590.     }
  1592.     final public function getFormTheme(): array
  1593.     {
  1594.         return $this->formTheme;
  1595.     }
  1597.     final public function setFilterTheme(array $filterTheme): void
  1598.     {
  1599.         $this->filterTheme = $filterTheme;
  1600.     }
  1602.     final public function getFilterTheme(): array
  1603.     {
  1604.         return $this->filterTheme;
  1605.     }
  1607.     final public function addExtension(AdminExtensionInterface $extension): void
  1608.     {
  1609.         $this->extensions[] = $extension;
  1610.     }
  1612.     /**
  1613.      * @phpstan-param AdminExtensionInterface<T> $extension
  1614.      */
  1615.     final public function removeExtension(AdminExtensionInterface $extension): void
  1616.     {
  1617.         $key = array_search($extension, $this->extensions, true);
  1618.         if (false === $key) {
  1619.             throw new \InvalidArgumentException(
  1620.                 sprintf('The extension "%s" was not set to the "%s" admin.', $extension::class, self::class)
  1621.             );
  1622.         }
  1624.         unset($this->extensions[$key]);
  1625.     }
  1627.     final public function getExtensions(): array
  1628.     {
  1629.         return $this->extensions;
  1630.     }
  1632.     public function toString(object $object): string
  1633.     {
  1634.         if (method_exists($object, '__toString') && null !== $object->__toString()) {
  1635.             return $object->__toString();
  1636.         }
  1638.         $modelManager = $this->getModelManager();
  1639.         if ($modelManager instanceof ProxyResolverInterface) {
  1640.             $class = $modelManager->getRealClass($object);
  1641.         } else {
  1642.             // NEXT_MAJOR: Change to `\get_class($object)`
  1643.             $class = BCHelper::getClass($object);
  1644.         }
  1646.         return sprintf('%s:%s', $class, spl_object_hash($object));
  1647.     }
  1649.     final public function supportsPreviewMode(): bool
  1650.     {
  1651.         return $this->supportsPreviewMode;
  1652.     }
  1654.     /**
  1655.      * Returns predefined per page options.
  1656.      *
  1657.      * @return array<int>
  1658.      */
  1659.     public function getPerPageOptions(): array
  1660.     {
  1661.         $perPageOptions = self::DEFAULT_LIST_PER_PAGE_OPTIONS;
  1662.         $perPageOptions[] = $this->getMaxPerPage();
  1664.         $perPageOptions = array_unique($perPageOptions);
  1665.         sort($perPageOptions);
  1667.         return $perPageOptions;
  1668.     }
  1670.     /**
  1671.      * Returns true if the per page value is allowed, false otherwise.
  1672.      */
  1673.     final public function determinedPerPageValue(int $perPage): bool
  1674.     {
  1675.         return \in_array($perPage, $this->getPerPageOptions(), true);
  1676.     }
  1678.     final public function isAclEnabled(): bool
  1679.     {
  1680.         return $this->getSecurityHandler() instanceof AclSecurityHandlerInterface;
  1681.     }
  1683.     public function getObjectMetadata(object $object): MetadataInterface
  1684.     {
  1685.         return new Metadata($this->toString($object));
  1686.     }
  1688.     final public function setListMode(string $mode): void
  1689.     {
  1690.         $this->getRequest()->getSession()->set(sprintf('%s.list_mode', $this->getCode()), $mode);
  1691.     }
  1693.     final public function getListMode(): string
  1694.     {
  1695.         $defaultListMode = array_keys($this->getListModes())[0];
  1696.         if (!$this->hasRequest() || !$this->getRequest()->hasSession()) {
  1697.             return $defaultListMode;
  1698.         }
  1700.         return $this->getRequest()->getSession()->get(sprintf('%s.list_mode', $this->getCode()), $defaultListMode);
  1701.     }
  1703.     final public function checkAccess(string $action, ?object $object = null): void
  1704.     {
  1705.         $access = $this->getAccess();
  1707.         if (!\array_key_exists($action, $access)) {
  1708.             throw new \InvalidArgumentException(sprintf(
  1709.                 'Action "%s" could not be found in access mapping.'
  1710.                 .' Please make sure your action is defined into your admin class accessMapping property.',
  1711.                 $action
  1712.             ));
  1713.         }
  1715.         if (!\is_array($access[$action])) {
  1716.             $access[$action] = [$access[$action]];
  1717.         }
  1719.         foreach ($access[$action] as $role) {
  1720.             if (false === $this->isGranted($role, $object)) {
  1721.                 throw new AccessDeniedException(sprintf('Access Denied to the action %s and role %s', $action, $role));
  1722.             }
  1723.         }
  1724.     }
  1726.     final public function hasAccess(string $action, ?object $object = null): bool
  1727.     {
  1728.         $access = $this->getAccess();
  1730.         if (!\array_key_exists($action, $access)) {
  1731.             return false;
  1732.         }
  1734.         if (!\is_array($access[$action])) {
  1735.             $access[$action] = [$access[$action]];
  1736.         }
  1738.         foreach ($access[$action] as $role) {
  1739.             if (false === $this->isGranted($role, $object)) {
  1740.                 return false;
  1741.             }
  1742.         }
  1744.         return true;
  1745.     }
  1747.     /**
  1748.      * @return array<string, array<string, mixed>>
  1749.      *
  1750.      * @phpstan-param T|null $object
  1751.      */
  1752.     final public function getActionButtons(string $action, ?object $object = null): array
  1753.     {
  1754.         $defaultButtonList = $this->getDefaultActionButtons($action, $object);
  1755.         $buttonList = $this->configureActionButtons($defaultButtonList, $action, $object);
  1757.         foreach ($this->getExtensions() as $extension) {
  1758.             $buttonList = $extension->configureActionButtons($this, $buttonList, $action, $object);
  1759.         }
  1761.         return $buttonList;
  1762.     }
  1764.     /**
  1765.      * Get the list of actions that can be accessed directly from the dashboard.
  1766.      *
  1767.      * @return array<string, array<string, mixed>>
  1768.      */
  1769.     final public function getDashboardActions(): array
  1770.     {
  1771.         $actions = [];
  1773.         if ($this->hasRoute('create') && $this->hasAccess('create')) {
  1774.             $actions['create'] = [
  1775.                 'label' => 'link_add',
  1776.                 'translation_domain' => 'SonataAdminBundle',
  1777.                 'template' => $this->getTemplateRegistry()->getTemplate('action_create'),
  1778.                 'url' => $this->generateUrl('create'),
  1779.                 'icon' => 'fas fa-plus-circle',
  1780.             ];
  1781.         }
  1783.         if ($this->hasRoute('list') && $this->hasAccess('list')) {
  1784.             $actions['list'] = [
  1785.                 'label' => 'link_list',
  1786.                 'translation_domain' => 'SonataAdminBundle',
  1787.                 'url' => $this->generateUrl('list'),
  1788.                 'icon' => 'fas fa-list',
  1789.             ];
  1790.         }
  1792.         $actions = $this->configureDashboardActions($actions);
  1794.         foreach ($this->getExtensions() as $extension) {
  1795.             $actions = $extension->configureDashboardActions($this, $actions);
  1796.         }
  1798.         return $actions;
  1799.     }
  1801.     final public function createFieldDescription(string $propertyName, array $options = []): FieldDescriptionInterface
  1802.     {
  1803.         $fieldDescriptionFactory = $this->getFieldDescriptionFactory();
  1805.         $fieldDescription = $fieldDescriptionFactory->create($this->getClass(), $propertyName, $options);
  1807.         $fieldDescription->setAdmin($this);
  1809.         return $fieldDescription;
  1810.     }
  1812.     /**
  1813.      * Hook to run after initialization.
  1814.      */
  1815.     protected function configure(): void
  1816.     {
  1817.     }
  1819.     protected function generateBaseRoutePattern(bool $isChildAdmin = false): string
  1820.     {
  1821.         // NEXT_MAJOR: Remove this code
  1822.         if (null !== $this->baseRoutePattern) {
  1823.             @trigger_error(sprintf(
  1824.                 'Overriding the baseRoutePattern property is deprecated since sonata-project/admin-bundle 4.15.'
  1825.                 .' You MUST override the method %s() instead.',
  1826.                 __METHOD__
  1827.             ), \E_USER_DEPRECATED);
  1829.             return $this->baseRoutePattern;
  1830.         }
  1832.         preg_match(self::CLASS_REGEX, $this->getModelClass(), $matches);
  1834.         if ([] === $matches) {
  1835.             throw new \LogicException(sprintf(
  1836.                 'Please define a default `baseRoutePattern` value for the admin class `%s`',
  1837.                 static::class
  1838.             ));
  1839.         }
  1841.         if ($isChildAdmin) {
  1842.             return $this->urlize($matches[5], '-');
  1843.         }
  1845.         return sprintf(
  1846.             '/%s%s/%s',
  1847.             '' === $matches[1] ? '' : $this->urlize($matches[1], '-').'/',
  1848.             $this->urlize($matches[3], '-'),
  1849.             $this->urlize($matches[5], '-')
  1850.         );
  1851.     }
  1853.     protected function generateBaseRouteName(bool $isChildAdmin = false): string
  1854.     {
  1855.         // NEXT_MAJOR: Remove this code
  1856.         if (null !== $this->baseRouteName) {
  1857.             @trigger_error(sprintf(
  1858.                 'Overriding the baseRouteName property is deprecated since sonata-project/admin-bundle 4.15.'
  1859.                 .' You MUST override the method %s() instead.',
  1860.                 __METHOD__
  1861.             ), \E_USER_DEPRECATED);
  1863.             return $this->baseRouteName;
  1864.         }
  1866.         preg_match(self::CLASS_REGEX, $this->getModelClass(), $matches);
  1868.         if ([] === $matches) {
  1869.             throw new \LogicException(sprintf(
  1870.                 'Cannot automatically determine base route name,'
  1871.                 .' please define a default `baseRouteName` value for the admin class `%s`',
  1872.                 static::class
  1873.             ));
  1874.         }
  1876.         if ($isChildAdmin) {
  1877.             return $this->urlize($matches[5]);
  1878.         }
  1880.         return sprintf(
  1881.             'admin_%s%s_%s',
  1882.             '' === $matches[1] ? '' : $this->urlize($matches[1]).'_',
  1883.             $this->urlize($matches[3]),
  1884.             $this->urlize($matches[5])
  1885.         );
  1886.     }
  1888.     /**
  1889.      * @phpstan-return T
  1890.      */
  1891.     protected function createNewInstance(): object
  1892.     {
  1893.         $object = Instantiator::instantiate($this->getClass());
  1894.         $this->appendParentObject($object);
  1896.         return $object;
  1897.     }
  1899.     /**
  1900.      * @phpstan-param T $object
  1901.      */
  1902.     protected function alterNewInstance(object $object): void
  1903.     {
  1904.     }
  1906.     /**
  1907.      * @phpstan-param T $object
  1908.      */
  1909.     protected function alterObject(object $object): void
  1910.     {
  1911.     }
  1913.     /**
  1914.      * @phpstan-param T $object
  1915.      */
  1916.     protected function preValidate(object $object): void
  1917.     {
  1918.     }
  1920.     /**
  1921.      * @phpstan-param T $object
  1922.      */
  1923.     protected function preUpdate(object $object): void
  1924.     {
  1925.     }
  1927.     /**
  1928.      * @phpstan-param T $object
  1929.      */
  1930.     protected function postUpdate(object $object): void
  1931.     {
  1932.     }
  1934.     /**
  1935.      * @phpstan-param T $object
  1936.      */
  1937.     protected function prePersist(object $object): void
  1938.     {
  1939.     }
  1941.     /**
  1942.      * @phpstan-param T $object
  1943.      */
  1944.     protected function postPersist(object $object): void
  1945.     {
  1946.     }
  1948.     /**
  1949.      * @phpstan-param T $object
  1950.      */
  1951.     protected function preRemove(object $object): void
  1952.     {
  1953.     }
  1955.     /**
  1956.      * @phpstan-param T $object
  1957.      */
  1958.     protected function postRemove(object $object): void
  1959.     {
  1960.     }
  1962.     /**
  1963.      * @return array<string, mixed>
  1964.      */
  1965.     protected function configurePersistentParameters(): array
  1966.     {
  1967.         return [];
  1968.     }
  1970.     /**
  1971.      * @return string[]
  1972.      */
  1973.     protected function configureExportFields(): array
  1974.     {
  1975.         return $this->getModelManager()->getExportFields($this->getClass());
  1976.     }
  1978.     /**
  1979.      * @param ProxyQueryInterface<T> $query
  1980.      *
  1981.      * @return ProxyQueryInterface<T>
  1982.      */
  1983.     protected function configureQuery(ProxyQueryInterface $query): ProxyQueryInterface
  1984.     {
  1985.         return $query;
  1986.     }
  1988.     /**
  1989.      * urlize the given word.
  1990.      *
  1991.      * @param string $sep the separator
  1992.      */
  1993.     final protected function urlize(string $word, string $sep = '_'): string
  1994.     {
  1995.         return strtolower(preg_replace('/[^a-z0-9_]/i', $sep.'$1', $word) ?? '');
  1996.     }
  1998.     /**
  1999.      * @param array<string, mixed> $parameters
  2000.      *
  2001.      * @return array<string, mixed>
  2002.      */
  2003.     protected function configureFilterParameters(array $parameters): array
  2004.     {
  2005.         return $parameters;
  2006.     }
  2008.     /**
  2009.      * Returns a list of default sort values.
  2010.      *
  2011.      * @phpstan-return array{
  2012.      *     _page?: int,
  2013.      *     _per_page?: int,
  2014.      *     _sort_by?: string,
  2015.      *     _sort_order?: string
  2016.      * }
  2017.      */
  2018.     final protected function getDefaultSortValues(): array
  2019.     {
  2020.         $defaultSortValues = [DatagridInterface::PAGE => 1, DatagridInterface::PER_PAGE => self::DEFAULT_LIST_PER_PAGE_RESULTS];
  2022.         $this->configureDefaultSortValues($defaultSortValues);
  2024.         foreach ($this->getExtensions() as $extension) {
  2025.             $extension->configureDefaultSortValues($this, $defaultSortValues);
  2026.         }
  2028.         return $defaultSortValues;
  2029.     }
  2031.     /**
  2032.      * Returns a list of default filters.
  2033.      *
  2034.      * @return array<string, array<string, mixed>>
  2035.      */
  2036.     final protected function getDefaultFilterValues(): array
  2037.     {
  2038.         $defaultFilterValues = [];
  2040.         $this->configureDefaultFilterValues($defaultFilterValues);
  2042.         foreach ($this->getExtensions() as $extension) {
  2043.             $extension->configureDefaultFilterValues($this, $defaultFilterValues);
  2044.         }
  2046.         return $defaultFilterValues;
  2047.     }
  2049.     /**
  2050.      * @return array<string, mixed>
  2051.      */
  2052.     final protected function getFormOptions(): array
  2053.     {
  2054.         $formOptions = [];
  2056.         $this->configureFormOptions($formOptions);
  2058.         foreach ($this->getExtensions() as $extension) {
  2059.             $extension->configureFormOptions($this, $formOptions);
  2060.         }
  2062.         return $formOptions;
  2063.     }
  2065.     /**
  2066.      * @phpstan-param FormMapper<T> $form
  2067.      */
  2068.     protected function configureFormFields(FormMapper $form): void
  2069.     {
  2070.     }
  2072.     /**
  2073.      * @phpstan-param ListMapper<T> $list
  2074.      */
  2075.     protected function configureListFields(ListMapper $list): void
  2076.     {
  2077.     }
  2079.     /**
  2080.      * @phpstan-param DatagridMapper<T> $filter
  2081.      */
  2082.     protected function configureDatagridFilters(DatagridMapper $filter): void
  2083.     {
  2084.     }
  2086.     /**
  2087.      * @phpstan-param ShowMapper<T> $show
  2088.      */
  2089.     protected function configureShowFields(ShowMapper $show): void
  2090.     {
  2091.     }
  2093.     protected function configureRoutes(RouteCollectionInterface $collection): void
  2094.     {
  2095.     }
  2097.     /**
  2098.      * @param array<string, array<string, mixed>> $buttonList
  2099.      *
  2100.      * @return array<string, array<string, mixed>>
  2101.      *
  2102.      * @phpstan-param T|null $object
  2103.      */
  2104.     protected function configureActionButtons(array $buttonList, string $action, ?object $object = null): array
  2105.     {
  2106.         return $buttonList;
  2107.     }
  2109.     /**
  2110.      * @param array<string, array<string, mixed>> $actions
  2111.      *
  2112.      * @return array<string, array<string, mixed>>
  2113.      */
  2114.     protected function configureDashboardActions(array $actions): array
  2115.     {
  2116.         return $actions;
  2117.     }
  2119.     /**
  2120.      * Allows you to customize batch actions.
  2121.      *
  2122.      * @param array<string, array<string, mixed>> $actions
  2123.      *
  2124.      * @return array<string, array<string, mixed>>
  2125.      */
  2126.     protected function configureBatchActions(array $actions): array
  2127.     {
  2128.         return $actions;
  2129.     }
  2131.     /**
  2132.      * Configures the tab menu in your admin.
  2133.      *
  2134.      * @phpstan-template TChild of object
  2135.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2136.      */
  2137.     protected function configureTabMenu(ItemInterface $menu, string $action, ?AdminInterface $childAdmin = null): void
  2138.     {
  2139.     }
  2141.     /**
  2142.      * Gets the subclass corresponding to the given name.
  2143.      *
  2144.      * @phpstan-return class-string<T>
  2145.      */
  2146.     protected function getSubClass(string $name): string
  2147.     {
  2148.         if ($this->hasSubClass($name)) {
  2149.             return $this->subClasses[$name];
  2150.         }
  2152.         throw new \LogicException(sprintf('Unable to find the subclass `%s` for admin `%s`', $name, static::class));
  2153.     }
  2155.     /**
  2156.      * Return list routes with permissions name.
  2157.      *
  2158.      * @return array<string, string|string[]>
  2159.      */
  2160.     final protected function getAccess(): array
  2161.     {
  2162.         $access = array_merge([
  2163.             'acl' => AdminPermissionMap::PERMISSION_MASTER,
  2164.             'export' => AdminPermissionMap::PERMISSION_EXPORT,
  2165.             'historyCompareRevisions' => AdminPermissionMap::PERMISSION_HISTORY,
  2166.             'historyViewRevision' => AdminPermissionMap::PERMISSION_HISTORY,
  2167.             'history' => AdminPermissionMap::PERMISSION_HISTORY,
  2168.             'edit' => AdminPermissionMap::PERMISSION_EDIT,
  2169.             'show' => AdminPermissionMap::PERMISSION_VIEW,
  2170.             'create' => AdminPermissionMap::PERMISSION_CREATE,
  2171.             'delete' => AdminPermissionMap::PERMISSION_DELETE,
  2172.             'batchDelete' => AdminPermissionMap::PERMISSION_DELETE,
  2173.             'list' => AdminPermissionMap::PERMISSION_LIST,
  2174.         ], $this->getAccessMapping());
  2176.         foreach ($this->getExtensions() as $extension) {
  2177.             $access = array_merge($access, $extension->getAccessMapping($this));
  2178.         }
  2180.         return $access;
  2181.     }
  2183.     /**
  2184.      * @return array<string, string|string[]> [action1 => requiredRole1, action2 => [requiredRole2, requiredRole3]]
  2185.      */
  2186.     protected function getAccessMapping(): array
  2187.     {
  2188.         return [];
  2189.     }
  2191.     /**
  2192.      * Return the list of permissions the user should have in order to display the admin.
  2193.      *
  2194.      * NEXT_MAJOR: Remove this method.
  2195.      *
  2196.      * @deprecated since sonata-project/admin-bundle version 4.7
  2197.      *
  2198.      * @return string[]
  2199.      */
  2200.     protected function getPermissionsShow(string $context): array
  2201.     {
  2202.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  2203.             @trigger_error(sprintf(
  2204.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  2205.                 .' removed in 5.0 version.',
  2206.                 __METHOD__
  2207.             ), \E_USER_DEPRECATED);
  2208.         }
  2210.         return ['LIST'];
  2211.     }
  2213.     /**
  2214.      * Configures a list of default filters.
  2215.      *
  2216.      * @param array<string, array<string, mixed>> $filterValues
  2217.      */
  2218.     protected function configureDefaultFilterValues(array &$filterValues): void
  2219.     {
  2220.     }
  2222.     /**
  2223.      * Configures a list of form options.
  2224.      *
  2225.      * @param array<string, mixed> $formOptions
  2226.      */
  2227.     protected function configureFormOptions(array &$formOptions): void
  2228.     {
  2229.     }
  2231.     /**
  2232.      * Configures a list of default sort values.
  2233.      *
  2234.      * Example:
  2235.      *   $sortValues[DatagridInterface::SORT_BY] = 'foo'
  2236.      *   $sortValues[DatagridInterface::SORT_ORDER] = 'DESC'
  2237.      *
  2238.      * @param array<string, string|int> $sortValues
  2239.      *
  2240.      * @phpstan-param array{
  2241.      *     _page?: int,
  2242.      *     _per_page?: int,
  2243.      *     _sort_by?: string,
  2244.      *     _sort_order?: string
  2245.      * } $sortValues
  2246.      */
  2247.     protected function configureDefaultSortValues(array &$sortValues): void
  2248.     {
  2249.     }
  2251.     /**
  2252.      * Set the parent object, if any, to the provided object.
  2253.      *
  2254.      * @phpstan-param T $object
  2255.      */
  2256.     final protected function appendParentObject(object $object): void
  2257.     {
  2258.         if ($this->isChild()) {
  2259.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2261.             if (null !== $parentAssociationMapping) {
  2262.                 $parentAdmin = $this->getParent();
  2263.                 $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2265.                 if (null !== $parentObject) {
  2266.                     $propertyAccessor = PropertyAccess::createPropertyAccessor();
  2268.                     try {
  2269.                         $value = $propertyAccessor->getValue($object, $parentAssociationMapping);
  2270.                     } catch (UninitializedPropertyException) {
  2271.                         $value = null;
  2272.                     }
  2274.                     if (\is_array($value) || $value instanceof \ArrayAccess) {
  2275.                         $value[] = $parentObject;
  2276.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $value);
  2277.                     } else {
  2278.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $parentObject);
  2279.                     }
  2280.                 }
  2282.                 return;
  2283.             }
  2284.         }
  2286.         if ($this->hasParentFieldDescription()) {
  2287.             $parentAdmin = $this->getParentFieldDescription()->getAdmin();
  2288.             $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2290.             if (null !== $parentObject) {
  2291.                 ObjectManipulator::setObject($object, $parentObject, $this->getParentFieldDescription());
  2292.             }
  2293.         }
  2294.     }
  2296.     /**
  2297.      * @return array<string, array<string, mixed>>
  2298.      *
  2299.      * @phpstan-param T|null $object
  2300.      */
  2301.     private function getDefaultActionButtons(string $action, ?object $object = null): array
  2302.     {
  2303.         // nothing to do for non-internal actions
  2304.         if (!isset(self::INTERNAL_ACTIONS[$action])) {
  2305.             return [];
  2306.         }
  2308.         $buttonList = [];
  2310.         $actionBit = self::INTERNAL_ACTIONS[$action];
  2312.         if (0 !== (self::MASK_OF_ACTION_CREATE & $actionBit)
  2313.             && $this->hasRoute('create')
  2314.             && $this->hasAccess('create')
  2315.         ) {
  2316.             $buttonList['create'] = [
  2317.                 'template' => $this->getTemplateRegistry()->getTemplate('button_create'),
  2318.             ];
  2319.         }
  2321.         $canAccessObject = 0 !== (self::MASK_OF_ACTIONS_USING_OBJECT & $actionBit)
  2322.             && null !== $object
  2323.             && null !== $this->id($object);
  2325.         if ($canAccessObject
  2326.             && 0 !== (self::MASK_OF_ACTION_EDIT & $actionBit)
  2327.             && $this->hasRoute('edit')
  2328.             && $this->hasAccess('edit', $object)
  2329.         ) {
  2330.             $buttonList['edit'] = [
  2331.                 'template' => $this->getTemplateRegistry()->getTemplate('button_edit'),
  2332.             ];
  2333.         }
  2335.         if ($canAccessObject
  2336.             && 0 !== (self::MASK_OF_ACTION_HISTORY & $actionBit)
  2337.             && $this->hasRoute('history')
  2338.             && $this->hasAccess('history', $object)
  2339.         ) {
  2340.             $buttonList['history'] = [
  2341.                 'template' => $this->getTemplateRegistry()->getTemplate('button_history'),
  2342.             ];
  2343.         }
  2345.         if ($canAccessObject
  2346.             && 0 !== (self::MASK_OF_ACTION_ACL & $actionBit)
  2347.             && $this->isAclEnabled()
  2348.             && $this->hasRoute('acl')
  2349.             && $this->hasAccess('acl', $object)
  2350.         ) {
  2351.             $buttonList['acl'] = [
  2352.                 'template' => $this->getTemplateRegistry()->getTemplate('button_acl'),
  2353.             ];
  2354.         }
  2356.         if ($canAccessObject
  2357.             && 0 !== (self::MASK_OF_ACTION_SHOW & $actionBit)
  2358.             && $this->hasRoute('show')
  2359.             && $this->hasAccess('show', $object)
  2360.             && \count($this->getShow()) > 0
  2361.         ) {
  2362.             $buttonList['show'] = [
  2363.                 'template' => $this->getTemplateRegistry()->getTemplate('button_show'),
  2364.             ];
  2365.         }
  2367.         if (0 !== (self::MASK_OF_ACTION_LIST & $actionBit)
  2368.             && $this->hasRoute('list')
  2369.             && $this->hasAccess('list')
  2370.         ) {
  2371.             $buttonList['list'] = [
  2372.                 'template' => $this->getTemplateRegistry()->getTemplate('button_list'),
  2373.             ];
  2374.         }
  2376.         return $buttonList;
  2377.     }
  2379.     /**
  2380.      * @return DatagridInterface<ProxyQueryInterface<T>>|null
  2381.      */
  2382.     private function buildDatagrid(): ?DatagridInterface
  2383.     {
  2384.         if ($this->loaded['datagrid']) {
  2385.             return $this->datagrid;
  2386.         }
  2388.         $this->loaded['datagrid'] = true;
  2390.         $filterParameters = $this->getFilterParameters();
  2392.         // transform DatagridInterface::SORT_BY filter parameter from a string to a FieldDescriptionInterface for the datagrid.
  2393.         if (isset($filterParameters[DatagridInterface::SORT_BY]) && \is_string($filterParameters[DatagridInterface::SORT_BY])) {
  2394.             if ($this->hasListFieldDescription($filterParameters[DatagridInterface::SORT_BY])) {
  2395.                 $filterParameters[DatagridInterface::SORT_BY] = $this->getListFieldDescription($filterParameters[DatagridInterface::SORT_BY]);
  2396.             } else {
  2397.                 $filterParameters[DatagridInterface::SORT_BY] = $this->createFieldDescription(
  2398.                     $filterParameters[DatagridInterface::SORT_BY]
  2399.                 );
  2401.                 $this->getListBuilder()->buildField(null, $filterParameters[DatagridInterface::SORT_BY]);
  2402.             }
  2403.         }
  2405.         // initialize the datagrid
  2406.         $this->datagrid = $this->getDatagridBuilder()->getBaseDatagrid($this, $filterParameters);
  2408.         $this->datagrid->getPager()->setMaxPageLinks($this->getMaxPageLinks());
  2410.         /** @psalm-suppress InvalidArgument https://github.com/vimeo/psalm/issues/8423 */
  2411.         $mapper = new DatagridMapper($this->getDatagridBuilder(), $this->datagrid, $this);
  2413.         // build the datagrid filter
  2414.         $this->configureDatagridFilters($mapper);
  2416.         // ok, try to limit to add parent filter
  2417.         if ($this->isChild()) {
  2418.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2420.             if (null !== $parentAssociationMapping && !$mapper->has($parentAssociationMapping)) {
  2421.                 $mapper->add($parentAssociationMapping, null, [
  2422.                     'show_filter' => false,
  2423.                     'label' => false,
  2424.                     'field_type' => ModelHiddenType::class,
  2425.                     'field_options' => [
  2426.                         'model_manager' => $this->getParent()->getModelManager(),
  2427.                         'class' => $this->getParent()->getClass(),
  2428.                     ],
  2429.                     'operator_type' => HiddenType::class,
  2430.                 ], [
  2431.                     'admin_code' => $this->getParent()->getCode(),
  2432.                 ]);
  2433.             }
  2434.         }
  2436.         foreach ($this->getExtensions() as $extension) {
  2437.             $extension->configureDatagridFilters($mapper);
  2438.         }
  2440.         return $this->datagrid;
  2441.     }
  2443.     /**
  2444.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2445.      */
  2446.     private function buildShow(): ?FieldDescriptionCollection
  2447.     {
  2448.         if ($this->loaded['show']) {
  2449.             return $this->show;
  2450.         }
  2452.         $this->loaded['show'] = true;
  2454.         $this->show = $this->getShowBuilder()->getBaseList();
  2455.         $mapper = new ShowMapper($this->getShowBuilder(), $this->show, $this);
  2457.         $this->configureShowFields($mapper);
  2459.         foreach ($this->getExtensions() as $extension) {
  2460.             $extension->configureShowFields($mapper);
  2461.         }
  2463.         return $this->show;
  2464.     }
  2466.     /**
  2467.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2468.      */
  2469.     private function buildList(): ?FieldDescriptionCollection
  2470.     {
  2471.         if ($this->loaded['list']) {
  2472.             return $this->list;
  2473.         }
  2475.         $this->loaded['list'] = true;
  2477.         $this->list = $this->getListBuilder()->getBaseList();
  2478.         $mapper = new ListMapper($this->getListBuilder(), $this->list, $this);
  2480.         if (\count($this->getBatchActions()) > 0 && $this->hasRequest() && !$this->getRequest()->isXmlHttpRequest()) {
  2481.             $mapper->add(ListMapper::NAME_BATCH, ListMapper::TYPE_BATCH, [
  2482.                 'label' => 'batch',
  2483.                 'sortable' => false,
  2484.                 'virtual_field' => true,
  2485.                 'template' => $this->getTemplateRegistry()->getTemplate('batch'),
  2486.             ]);
  2487.         }
  2489.         $this->configureListFields($mapper);
  2491.         foreach ($this->getExtensions() as $extension) {
  2492.             $extension->configureListFields($mapper);
  2493.         }
  2495.         if ($this->hasRequest()
  2496.             && $this->getRequest()->isXmlHttpRequest()
  2497.             && $this->getRequest()->query->getBoolean('select', true) // NEXT_MAJOR: Change the default value to `false` in version 5
  2498.         ) {
  2499.             $mapper->add(ListMapper::NAME_SELECT, ListMapper::TYPE_SELECT, [
  2500.                 'label' => false,
  2501.                 'sortable' => false,
  2502.                 'virtual_field' => false,
  2503.                 'template' => $this->getTemplateRegistry()->getTemplate('select'),
  2504.             ]);
  2505.         }
  2507.         return $this->list;
  2508.     }
  2510.     private function buildForm(): ?FormInterface
  2511.     {
  2512.         if ($this->loaded['form']) {
  2513.             return $this->form;
  2514.         }
  2516.         $this->loaded['form'] = true;
  2518.         $formBuilder = $this->getFormBuilder();
  2519.         $formBuilder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event): void {
  2520.             /** @phpstan-var T $data */
  2521.             $data = $event->getData();
  2522.             $this->preValidate($data);
  2523.         }, 100);
  2525.         $this->form = $formBuilder->getForm();
  2527.         return $this->form;
  2528.     }
  2530.     private function buildRoutes(): ?RouteCollectionInterface
  2531.     {
  2532.         if ($this->loaded['routes']) {
  2533.             return $this->routes;
  2534.         }
  2536.         $this->loaded['routes'] = true;
  2538.         $routes = new RouteCollection(
  2539.             $this->getBaseCodeRoute(),
  2540.             $this->getBaseRouteName(),
  2541.             $this->getBaseRoutePattern(),
  2542.             $this->getBaseControllerName()
  2543.         );
  2545.         $this->getRouteBuilder()->build($this, $routes);
  2547.         $this->configureRoutes($routes);
  2549.         foreach ($this->getExtensions() as $extension) {
  2550.             $extension->configureRoutes($this, $routes);
  2551.         }
  2553.         $this->routes = $routes;
  2555.         return $this->routes;
  2556.     }
  2558.     /**
  2559.      * @phpstan-template TChild of object
  2560.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2561.      */
  2562.     private function buildTabMenu(string $action, ?AdminInterface $childAdmin = null): ?ItemInterface
  2563.     {
  2564.         if ($this->loaded['tab_menu']) {
  2565.             return $this->menu;
  2566.         }
  2568.         $this->loaded['tab_menu'] = true;
  2570.         $menu = $this->getMenuFactory()->createItem('root');
  2571.         $menu->setChildrenAttribute('class', 'nav navbar-nav');
  2572.         $menu->setExtra('translation_domain', $this->getTranslationDomain());
  2574.         $this->configureTabMenu($menu, $action, $childAdmin);
  2576.         foreach ($this->getExtensions() as $extension) {
  2577.             $extension->configureTabMenu($this, $menu, $action, $childAdmin);
  2578.         }
  2580.         $this->menu = $menu;
  2582.         return $this->menu;
  2583.     }
  2584. }