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

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 Doctrine\Common\Util\ClassUtils;
  17. use Knp\Menu\ItemInterface;
  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\Object\Metadata;
  30. use Sonata\AdminBundle\Object\MetadataInterface;
  31. use Sonata\AdminBundle\Route\RouteCollection;
  32. use Sonata\AdminBundle\Route\RouteCollectionInterface;
  33. use Sonata\AdminBundle\Security\Acl\Permission\AdminPermissionMap;
  34. use Sonata\AdminBundle\Security\Handler\AclSecurityHandlerInterface;
  35. use Sonata\AdminBundle\Show\ShowMapper;
  36. use Sonata\AdminBundle\Util\Instantiator;
  37. use Sonata\AdminBundle\Util\ParametersManipulator;
  38. use Sonata\Exporter\Source\SourceIteratorInterface;
  39. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  40. use Symfony\Component\Form\FormBuilderInterface;
  41. use Symfony\Component\Form\FormEvent;
  42. use Symfony\Component\Form\FormEvents;
  43. use Symfony\Component\Form\FormInterface;
  44. use Symfony\Component\HttpFoundation\InputBag;
  45. use Symfony\Component\HttpFoundation\ParameterBag;
  46. use Symfony\Component\HttpFoundation\Request;
  47. use Symfony\Component\PropertyAccess\PropertyAccess;
  48. use Symfony\Component\Routing\Generator\UrlGeneratorInterface as RoutingUrlGeneratorInterface;
  49. use Symfony\Component\Security\Acl\Model\DomainObjectInterface;
  50. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  52. /**
  53.  * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
  54.  *
  55.  * @phpstan-template T of object
  56.  * @phpstan-extends AbstractTaggedAdmin<T>
  57.  * @phpstan-implements AdminInterface<T>
  58.  */
  59. abstract class AbstractAdmin extends AbstractTaggedAdmin implements AdminInterface, DomainObjectInterface, AdminTreeInterface
  60. {
  61.     // NEXT_MAJOR: Remove the CONTEXT constants.
  62.     /** @deprecated */
  63.     public const CONTEXT_MENU = 'menu';
  64.     /** @deprecated */
  65.     public const CONTEXT_DASHBOARD = 'dashboard';
  67.     public const CLASS_REGEX =
  68.         '@
  69.         (?:([A-Za-z0-9]*)\\\)?        # vendor name / app name
  70.         (Bundle\\\)?                  # optional bundle directory
  71.         ([A-Za-z0-9]+?)(?:Bundle)?\\\ # bundle name, with optional suffix
  72.         (
  73.             Entity|Document|Model|PHPCR|CouchDocument|Phpcr|
  74.             Doctrine\\\Orm|Doctrine\\\Phpcr|Doctrine\\\MongoDB|Doctrine\\\CouchDB
  75.         )\\\(.*)@x';
  77.     private const ACTION_TREE = 1;
  78.     private const ACTION_SHOW = 2;
  79.     private const ACTION_EDIT = 4;
  80.     private const ACTION_DELETE = 8;
  81.     private const ACTION_ACL = 16;
  82.     private const ACTION_HISTORY = 32;
  83.     private const ACTION_LIST = 64;
  84.     private const ACTION_BATCH = 128;
  85.     private const INTERNAL_ACTIONS = [
  86.         'tree' => self::ACTION_TREE,
  87.         'show' => self::ACTION_SHOW,
  88.         'edit' => self::ACTION_EDIT,
  89.         'delete' => self::ACTION_DELETE,
  90.         'acl' => self::ACTION_ACL,
  91.         'history' => self::ACTION_HISTORY,
  92.         'list' => self::ACTION_LIST,
  93.         'batch' => self::ACTION_BATCH,
  94.     ];
  95.     private const MASK_OF_ACTION_CREATE = self::ACTION_TREE | self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_LIST | self::ACTION_BATCH;
  96.     private const MASK_OF_ACTION_SHOW = self::ACTION_EDIT | self::ACTION_HISTORY | self::ACTION_ACL;
  97.     private const MASK_OF_ACTION_EDIT = self::ACTION_SHOW | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_HISTORY;
  98.     private const MASK_OF_ACTION_HISTORY = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_ACL;
  99.     private const MASK_OF_ACTION_ACL = self::ACTION_EDIT | self::ACTION_HISTORY;
  100.     private const MASK_OF_ACTION_LIST = self::ACTION_SHOW | self::ACTION_EDIT | self::ACTION_DELETE | self::ACTION_ACL | self::ACTION_BATCH;
  101.     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;
  103.     private const DEFAULT_LIST_PER_PAGE_RESULTS = 25;
  104.     private const DEFAULT_LIST_PER_PAGE_OPTIONS = [10, 25, 50, 100, 250];
  106.     /**
  107.      * The base route name used to generate the routing information.
  108.      *
  109.      * @var string|null
  110.      */
  111.     protected $baseRouteName;
  113.     /**
  114.      * The base route pattern used to generate the routing information.
  115.      *
  116.      * @var string|null
  117.      */
  118.     protected $baseRoutePattern;
  120.     /**
  121.      * The label class name  (used in the title/breadcrumb ...).
  122.      *
  123.      * @var string|null
  124.      */
  125.     protected $classnameLabel;
  127.     /**
  128.      * Setting to true will enable preview mode for
  129.      * the entity and show a preview button in the
  130.      * edit/create forms.
  131.      *
  132.      * @var bool
  133.      */
  134.     protected $supportsPreviewMode = false;
  136.     /**
  137.      * The list FieldDescription constructed from the configureListField method.
  138.      *
  139.      * @var array<string, FieldDescriptionInterface>
  140.      */
  141.     private $listFieldDescriptions = [];
  143.     /**
  144.      * The show FieldDescription constructed from the configureShowFields method.
  145.      *
  146.      * @var FieldDescriptionInterface[]
  147.      */
  148.     private $showFieldDescriptions = [];
  150.     /**
  151.      * The list FieldDescription constructed from the configureFormField method.
  152.      *
  153.      * @var FieldDescriptionInterface[]
  154.      */
  155.     private $formFieldDescriptions = [];
  157.     /**
  158.      * The filter FieldDescription constructed from the configureFilterField method.
  159.      *
  160.      * @var FieldDescriptionInterface[]
  161.      */
  162.     private $filterFieldDescriptions = [];
  164.     /**
  165.      * The maximum number of page numbers to display in the list.
  166.      *
  167.      * @var int
  168.      */
  169.     private $maxPageLinks = 25;
  171.     /**
  172.      * The translation domain to be used to translate messages.
  173.      *
  174.      * @var string
  175.      */
  176.     private $translationDomain = 'messages';
  178.     /**
  179.      * Array of routes related to this admin.
  180.      *
  181.      * @var RouteCollectionInterface|null
  182.      */
  183.     private $routes;
  185.     /**
  186.      * The subject only set in edit/update/create mode.
  187.      *
  188.      * @var object|null
  189.      *
  190.      * @phpstan-var T|null
  191.      */
  192.     private $subject;
  194.     /**
  195.      * Define a Collection of child admin, ie /admin/order/{id}/order-element/{childId}.
  196.      *
  197.      * @var array<string, AdminInterface<object>>
  198.      */
  199.     private $children = [];
  201.     /**
  202.      * Reference the parent admin.
  203.      *
  204.      * @var AdminInterface<object>|null
  205.      */
  206.     private $parent;
  208.     /**
  209.      * Reference the parent FieldDescription related to this admin
  210.      * only set for FieldDescription which is associated to an Sub Admin instance.
  211.      *
  212.      * @var FieldDescriptionInterface|null
  213.      */
  214.     private $parentFieldDescription;
  216.     /**
  217.      * If true then the current admin is part of the nested admin set (from the url).
  218.      *
  219.      * @var bool
  220.      */
  221.     private $currentChild = false;
  223.     /**
  224.      * The uniqId is used to avoid clashing with 2 admin related to the code
  225.      * ie: a Block linked to a Block.
  226.      *
  227.      * @var string|null
  228.      */
  229.     private $uniqId;
  231.     /**
  232.      * The current request object.
  233.      *
  234.      * @var Request|null
  235.      */
  236.     private $request;
  238.     /**
  239.      * The datagrid instance.
  240.      *
  241.      * @var DatagridInterface<ProxyQueryInterface>|null
  242.      */
  243.     private $datagrid;
  245.     /**
  246.      * @var ItemInterface|null
  247.      */
  248.     private $menu;
  250.     /**
  251.      * @var string[]
  252.      */
  253.     private $formTheme = [];
  255.     /**
  256.      * @var string[]
  257.      */
  258.     private $filterTheme = [];
  260.     /**
  261.      * @var AdminExtensionInterface[]
  262.      * @phpstan-var array<AdminExtensionInterface<T>>
  263.      */
  264.     private $extensions = [];
  266.     /**
  267.      * @var array<string, bool>
  268.      */
  269.     private $cacheIsGranted = [];
  271.     /**
  272.      * @var array<string, string>
  273.      */
  274.     private $parentAssociationMapping = [];
  276.     /**
  277.      * The subclasses supported by the admin class.
  278.      *
  279.      * @var string[]
  280.      * @phpstan-var array<string, class-string<T>>
  281.      */
  282.     private $subClasses = [];
  284.     /**
  285.      * The list collection.
  286.      *
  287.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  288.      */
  289.     private $list;
  291.     /**
  292.      * @var FieldDescriptionCollection<FieldDescriptionInterface>|null
  293.      */
  294.     private $show;
  296.     /**
  297.      * @var FormInterface|null
  298.      */
  299.     private $form;
  301.     /**
  302.      * The cached base route name.
  303.      *
  304.      * @var string|null
  305.      */
  306.     private $cachedBaseRouteName;
  308.     /**
  309.      * The cached base route pattern.
  310.      *
  311.      * @var string|null
  312.      */
  313.     private $cachedBaseRoutePattern;
  315.     /**
  316.      * The form group disposition.
  317.      *
  318.      * @var array<string, mixed>
  319.      */
  320.     private $formGroups = [];
  322.     /**
  323.      * The form tabs disposition.
  324.      *
  325.      * @var array<string, mixed>
  326.      */
  327.     private $formTabs = [];
  329.     /**
  330.      * The view group disposition.
  331.      *
  332.      * @var array<string, mixed>
  333.      */
  334.     private $showGroups = [];
  336.     /**
  337.      * The view tab disposition.
  338.      *
  339.      * @var array<string, mixed>
  340.      */
  341.     private $showTabs = [];
  343.     /**
  344.      * @var array<string, bool>
  345.      */
  346.     private $loaded = [
  347.         'routes' => false,
  348.         'tab_menu' => false,
  349.         'show' => false,
  350.         'list' => false,
  351.         'form' => false,
  352.         'datagrid' => false,
  353.     ];
  355.     public function getExportFormats(): array
  356.     {
  357.         return [];
  358.     }
  360.     final public function getExportFields(): array
  361.     {
  362.         $fields = $this->configureExportFields();
  364.         foreach ($this->getExtensions() as $extension) {
  365.             $fields = $extension->configureExportFields($this, $fields);
  366.         }
  368.         return $fields;
  369.     }
  371.     final public function getDataSourceIterator(): SourceIteratorInterface
  372.     {
  373.         $datagrid = $this->getDatagrid();
  374.         $datagrid->buildPager();
  376.         $fields = [];
  378.         foreach ($this->getExportFields() as $key => $field) {
  379.             if (!\is_string($key)) {
  380.                 $label = $this->getTranslationLabel($field, 'export', 'label');
  381.                 $key = $this->getTranslator()->trans($label, [], $this->getTranslationDomain());
  382.             }
  384.             $fields[$key] = $field;
  385.         }
  387.         $query = $datagrid->getQuery();
  389.         return $this->getDataSource()->createIterator($query, $fields);
  390.     }
  392.     final public function initialize(): void
  393.     {
  394.         if (null === $this->classnameLabel) {
  395.             $namespaceSeparatorPos = strrpos($this->getClass(), '\\');
  396.             $this->classnameLabel = false !== $namespaceSeparatorPos
  397.                 ? substr($this->getClass(), $namespaceSeparatorPos + 1)
  398.                 : $this->getClass();
  399.         }
  401.         $this->configure();
  403.         foreach ($this->getExtensions() as $extension) {
  404.             $extension->configure($this);
  405.         }
  406.     }
  408.     final public function update(object $object): object
  409.     {
  410.         $this->preUpdate($object);
  411.         foreach ($this->getExtensions() as $extension) {
  412.             $extension->preUpdate($this, $object);
  413.         }
  415.         $this->getModelManager()->update($object);
  417.         $this->postUpdate($object);
  418.         foreach ($this->getExtensions() as $extension) {
  419.             $extension->postUpdate($this, $object);
  420.         }
  422.         return $object;
  423.     }
  425.     final public function create(object $object): object
  426.     {
  427.         $this->prePersist($object);
  428.         foreach ($this->getExtensions() as $extension) {
  429.             $extension->prePersist($this, $object);
  430.         }
  432.         $this->getModelManager()->create($object);
  434.         $this->postPersist($object);
  435.         foreach ($this->getExtensions() as $extension) {
  436.             $extension->postPersist($this, $object);
  437.         }
  439.         $this->createObjectSecurity($object);
  441.         return $object;
  442.     }
  444.     final public function delete(object $object): void
  445.     {
  446.         $this->preRemove($object);
  447.         foreach ($this->getExtensions() as $extension) {
  448.             $extension->preRemove($this, $object);
  449.         }
  451.         $this->getSecurityHandler()->deleteObjectSecurity($this, $object);
  452.         $this->getModelManager()->delete($object);
  454.         $this->postRemove($object);
  455.         foreach ($this->getExtensions() as $extension) {
  456.             $extension->postRemove($this, $object);
  457.         }
  458.     }
  460.     public function preBatchAction(string $actionName, ProxyQueryInterface $query, array &$idx, bool $allElements = false): void
  461.     {
  462.     }
  464.     final public function getDefaultFilterParameters(): array
  465.     {
  466.         return array_merge(
  467.             $this->getDefaultSortValues(),
  468.             $this->getDefaultFilterValues()
  469.         );
  470.     }
  472.     final public function getFilterParameters(): array
  473.     {
  474.         $parameters = $this->getDefaultFilterParameters();
  476.         // build the values array
  477.         if ($this->hasRequest()) {
  478.             /** @var InputBag|ParameterBag $bag */
  479.             $bag = $this->getRequest()->query;
  480.             if ($bag instanceof InputBag) {
  481.                 // symfony 5.1+
  482.                 $filters = $bag->all('filter');
  483.             } else {
  484.                 $filters = $bag->get('filter', []);
  485.             }
  486.             if (isset($filters[DatagridInterface::PAGE])) {
  487.                 $filters[DatagridInterface::PAGE] = (int) $filters[DatagridInterface::PAGE];
  488.             }
  489.             if (isset($filters[DatagridInterface::PER_PAGE])) {
  490.                 $filters[DatagridInterface::PER_PAGE] = (int) $filters[DatagridInterface::PER_PAGE];
  491.             }
  493.             // if filter persistence is configured
  494.             if ($this->hasFilterPersister()) {
  495.                 // if reset filters is asked, remove from storage
  496.                 if ('reset' === $this->getRequest()->query->get('filters')) {
  497.                     $this->getFilterPersister()->reset($this->getCode());
  498.                 }
  500.                 // if no filters, fetch from storage
  501.                 // otherwise save to storage
  502.                 if ([] === $filters) {
  503.                     $filters = $this->getFilterPersister()->get($this->getCode());
  504.                 } else {
  505.                     $this->getFilterPersister()->set($this->getCode(), $filters);
  506.                 }
  507.             }
  509.             $parameters = ParametersManipulator::merge($parameters, $filters);
  511.             // always force the parent value
  512.             if ($this->isChild()) {
  513.                 $parentAssociationMapping = $this->getParentAssociationMapping();
  514.                 if (null !== $parentAssociationMapping) {
  515.                     $name = str_replace('.', '__', $parentAssociationMapping);
  516.                     $parameters[$name] = ['value' => $this->getRequest()->get($this->getParent()->getIdParameter())];
  517.                 }
  518.             }
  519.         }
  521.         if (
  522.             !isset($parameters[DatagridInterface::PER_PAGE])
  523.             || !\is_int($parameters[DatagridInterface::PER_PAGE])
  524.             || !$this->determinedPerPageValue($parameters[DatagridInterface::PER_PAGE])
  525.         ) {
  526.             $parameters[DatagridInterface::PER_PAGE] = $this->getMaxPerPage();
  527.         }
  529.         $parameters = $this->configureFilterParameters($parameters);
  531.         foreach ($this->getExtensions() as $extension) {
  532.             $parameters = $extension->configureFilterParameters($this, $parameters);
  533.         }
  535.         return $parameters;
  536.     }
  538.     /**
  539.      * Returns the name of the parent related field, so the field can be use to set the default
  540.      * value (ie the parent object) or to filter the object.
  541.      *
  542.      * @throws \LogicException
  543.      */
  544.     final public function getParentAssociationMapping(): ?string
  545.     {
  546.         if (!$this->isChild()) {
  547.             throw new \LogicException(sprintf(
  548.                 'Admin "%s" has no parent.',
  549.                 static::class
  550.             ));
  551.         }
  553.         $parent = $this->getParent()->getCode();
  555.         return $this->parentAssociationMapping[$parent];
  556.     }
  558.     final public function getBaseRoutePattern(): string
  559.     {
  560.         if (null !== $this->cachedBaseRoutePattern) {
  561.             return $this->cachedBaseRoutePattern;
  562.         }
  564.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route pattern
  565.             $baseRoutePattern = $this->baseRoutePattern;
  566.             if (null === $baseRoutePattern) {
  567.                 preg_match(self::CLASS_REGEX, $this->class, $matches);
  569.                 if (!$matches) {
  570.                     throw new \LogicException(sprintf(
  571.                         'Please define a default `baseRoutePattern` value for the admin class `%s`',
  572.                         static::class
  573.                     ));
  574.                 }
  575.                 $baseRoutePattern = $this->urlize($matches[5], '-');
  576.             }
  578.             $this->cachedBaseRoutePattern = sprintf(
  579.                 '%s/%s/%s',
  580.                 $this->getParent()->getBaseRoutePattern(),
  581.                 $this->getParent()->getRouterIdParameter(),
  582.                 $baseRoutePattern
  583.             );
  584.         } elseif (null !== $this->baseRoutePattern) {
  585.             $this->cachedBaseRoutePattern = $this->baseRoutePattern;
  586.         } else {
  587.             preg_match(self::CLASS_REGEX, $this->class, $matches);
  589.             if (!$matches) {
  590.                 throw new \LogicException(sprintf(
  591.                     'Please define a default `baseRoutePattern` value for the admin class `%s`',
  592.                     static::class
  593.                 ));
  594.             }
  596.             $this->cachedBaseRoutePattern = sprintf(
  597.                 '/%s%s/%s',
  598.                 '' === $matches[1] ? '' : $this->urlize($matches[1], '-').'/',
  599.                 $this->urlize($matches[3], '-'),
  600.                 $this->urlize($matches[5], '-')
  601.             );
  602.         }
  604.         return $this->cachedBaseRoutePattern;
  605.     }
  607.     /**
  608.      * Returns the baseRouteName used to generate the routing information.
  609.      *
  610.      * @return string the baseRouteName used to generate the routing information
  611.      */
  612.     final public function getBaseRouteName(): string
  613.     {
  614.         if (null !== $this->cachedBaseRouteName) {
  615.             return $this->cachedBaseRouteName;
  616.         }
  618.         if ($this->isChild()) { // the admin class is a child, prefix it with the parent route name
  619.             $baseRouteName = $this->baseRouteName;
  620.             if (null === $baseRouteName) {
  621.                 preg_match(self::CLASS_REGEX, $this->class, $matches);
  623.                 if (!$matches) {
  624.                     throw new \LogicException(sprintf(
  625.                         'Cannot automatically determine base route name,'
  626.                         .' please define a default `baseRouteName` value for the admin class `%s`',
  627.                         static::class
  628.                     ));
  629.                 }
  630.                 $baseRouteName = $this->urlize($matches[5]);
  631.             }
  633.             $this->cachedBaseRouteName = sprintf(
  634.                 '%s_%s',
  635.                 $this->getParent()->getBaseRouteName(),
  636.                 $baseRouteName
  637.             );
  638.         } elseif (null !== $this->baseRouteName) {
  639.             $this->cachedBaseRouteName = $this->baseRouteName;
  640.         } else {
  641.             preg_match(self::CLASS_REGEX, $this->class, $matches);
  643.             if (!$matches) {
  644.                 throw new \LogicException(sprintf(
  645.                     'Cannot automatically determine base route name,'
  646.                     .' please define a default `baseRouteName` value for the admin class `%s`',
  647.                     static::class
  648.                 ));
  649.             }
  651.             $this->cachedBaseRouteName = sprintf(
  652.                 'admin_%s%s_%s',
  653.                 '' === $matches[1] ? '' : $this->urlize($matches[1]).'_',
  654.                 $this->urlize($matches[3]),
  655.                 $this->urlize($matches[5])
  656.             );
  657.         }
  659.         return $this->cachedBaseRouteName;
  660.     }
  662.     final public function getClass(): string
  663.     {
  664.         if ($this->hasActiveSubClass()) {
  665.             if ($this->hasParentFieldDescription()) {
  666.                 throw new \LogicException('Feature not implemented: an embedded admin cannot have subclass');
  667.             }
  669.             $subClass = $this->getRequest()->query->get('subclass');
  670.             \assert(\is_string($subClass));
  672.             if (!$this->hasSubClass($subClass)) {
  673.                 throw new \LogicException(sprintf('Subclass "%s" is not defined.', $subClass));
  674.             }
  676.             return $this->getSubClass($subClass);
  677.         }
  679.         // Do not use `$this->hasSubject()` and `$this->getSubject()` here to avoid infinite loop.
  680.         // `getSubject` use `hasSubject()` which use `getObject()` which use `getClass()`.
  681.         if (null !== $this->subject) {
  682.             /** @phpstan-var class-string<T> $class */
  683.             $class = ClassUtils::getClass($this->subject);
  685.             return $class;
  686.         }
  688.         return $this->class;
  689.     }
  691.     final public function getSubClasses(): array
  692.     {
  693.         return $this->subClasses;
  694.     }
  696.     final public function setSubClasses(array $subClasses): void
  697.     {
  698.         $this->subClasses = $subClasses;
  699.     }
  701.     final public function hasSubClass(string $name): bool
  702.     {
  703.         return isset($this->subClasses[$name]);
  704.     }
  706.     final public function hasActiveSubClass(): bool
  707.     {
  708.         if (\count($this->subClasses) > 0 && $this->hasRequest()) {
  709.             return \is_string($this->getRequest()->query->get('subclass'));
  710.         }
  712.         return false;
  713.     }
  715.     final public function getActiveSubClass(): string
  716.     {
  717.         if (!$this->hasActiveSubClass()) {
  718.             throw new \LogicException(sprintf(
  719.                 'Admin "%s" has no active subclass.',
  720.                 static::class
  721.             ));
  722.         }
  724.         return $this->getSubClass($this->getActiveSubclassCode());
  725.     }
  727.     final public function getActiveSubclassCode(): string
  728.     {
  729.         if (!$this->hasActiveSubClass()) {
  730.             throw new \LogicException(sprintf(
  731.                 'Admin "%s" has no active subclass.',
  732.                 static::class
  733.             ));
  734.         }
  736.         $subClass = (string) $this->getRequest()->query->get('subclass');
  738.         if (!$this->hasSubClass($subClass)) {
  739.             throw new \LogicException(sprintf(
  740.                 'Admin "%s" has no active subclass.',
  741.                 static::class
  742.             ));
  743.         }
  745.         return $subClass;
  746.     }
  748.     final public function getBatchActions(): array
  749.     {
  750.         if (!$this->hasRoute('batch')) {
  751.             return [];
  752.         }
  754.         $actions = [];
  756.         if ($this->hasRoute('delete') && $this->hasAccess('delete')) {
  757.             $actions['delete'] = [
  758.                 'label' => 'action_delete',
  759.                 'translation_domain' => 'SonataAdminBundle',
  760.                 'ask_confirmation' => true, // by default always true
  761.             ];
  762.         }
  764.         $actions = $this->configureBatchActions($actions);
  766.         foreach ($this->getExtensions() as $extension) {
  767.             $actions = $extension->configureBatchActions($this, $actions);
  768.         }
  770.         foreach ($actions as $name => &$action) {
  771.             if (!\array_key_exists('label', $action)) {
  772.                 $action['label'] = $this->getTranslationLabel($name, 'batch', 'label');
  773.             }
  775.             if (!\array_key_exists('translation_domain', $action)) {
  776.                 $action['translation_domain'] = $this->getTranslationDomain();
  777.             }
  778.         }
  780.         return $actions;
  781.     }
  783.     final public function getRoutes(): RouteCollectionInterface
  784.     {
  785.         $routes = $this->buildRoutes();
  786.         if (null === $routes) {
  787.             throw new \LogicException('Cannot access routes during the building process.');
  788.         }
  790.         return $routes;
  791.     }
  793.     public function getRouterIdParameter(): string
  794.     {
  795.         return sprintf('{%s}', $this->getIdParameter());
  796.     }
  798.     public function getIdParameter(): string
  799.     {
  800.         $parameter = 'id';
  802.         for ($i = 0; $i < $this->getChildDepth(); ++$i) {
  803.             $parameter = sprintf('child%s', ucfirst($parameter));
  804.         }
  806.         return $parameter;
  807.     }
  809.     final public function hasRoute(string $name): bool
  810.     {
  811.         return $this->getRouteGenerator()->hasAdminRoute($this, $name);
  812.     }
  814.     final public function isCurrentRoute(string $name, ?string $adminCode = null): bool
  815.     {
  816.         if (!$this->hasRequest()) {
  817.             return false;
  818.         }
  820.         $request = $this->getRequest();
  821.         $route = $request->get('_route');
  823.         if (null !== $adminCode) {
  824.             $pool = $this->getConfigurationPool();
  826.             if ($pool->hasAdminByAdminCode($adminCode)) {
  827.                 $admin = $pool->getAdminByAdminCode($adminCode);
  828.             } else {
  829.                 return false;
  830.             }
  831.         } else {
  832.             $admin = $this;
  833.         }
  835.         return $admin->getRoutes()->getRouteName($name) === $route;
  836.     }
  838.     final public function generateObjectUrl(string $name, object $object, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  839.     {
  840.         $parameters[$this->getIdParameter()] = $this->getUrlSafeIdentifier($object);
  842.         return $this->generateUrl($name, $parameters, $referenceType);
  843.     }
  845.     final public function generateUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): string
  846.     {
  847.         return $this->getRouteGenerator()->generateUrl($this, $name, $parameters, $referenceType);
  848.     }
  850.     final public function generateMenuUrl(string $name, array $parameters = [], int $referenceType = RoutingUrlGeneratorInterface::ABSOLUTE_PATH): array
  851.     {
  852.         return $this->getRouteGenerator()->generateMenuUrl($this, $name, $parameters, $referenceType);
  853.     }
  855.     final public function getNewInstance(): object
  856.     {
  857.         $object = $this->createNewInstance();
  859.         $this->alterNewInstance($object);
  861.         foreach ($this->getExtensions() as $extension) {
  862.             $extension->alterNewInstance($this, $object);
  863.         }
  865.         return $object;
  866.     }
  868.     final public function getFormBuilder(): FormBuilderInterface
  869.     {
  870.         $formBuilder = $this->getFormContractor()->getFormBuilder(
  871.             $this->getUniqId(),
  872.             ['data_class' => $this->getClass()] + $this->getFormOptions(),
  873.         );
  875.         $this->defineFormBuilder($formBuilder);
  877.         return $formBuilder;
  878.     }
  880.     /**
  881.      * This method is being called by the main admin class and the child class,
  882.      * the getFormBuilder is only call by the main admin class.
  883.      */
  884.     final public function defineFormBuilder(FormBuilderInterface $formBuilder): void
  885.     {
  886.         if (!$this->hasSubject()) {
  887.             throw new \LogicException(sprintf(
  888.                 'Admin "%s" has no subject.',
  889.                 static::class
  890.             ));
  891.         }
  893.         $mapper = new FormMapper($this->getFormContractor(), $formBuilder, $this);
  895.         $this->configureFormFields($mapper);
  897.         foreach ($this->getExtensions() as $extension) {
  898.             $extension->configureFormFields($mapper);
  899.         }
  900.     }
  902.     final public function attachAdminClass(FieldDescriptionInterface $fieldDescription): void
  903.     {
  904.         $pool = $this->getConfigurationPool();
  906.         try {
  907.             $admin = $pool->getAdminByFieldDescription($fieldDescription);
  908.         } catch (AdminClassNotFoundException $exception) {
  909.             // Using a fieldDescription with no admin class for the target model is a valid case.
  910.             // Since there is no easy way to check for this case, we catch the exception instead.
  911.             return;
  912.         }
  914.         if ($this->hasRequest()) {
  915.             $admin->setRequest($this->getRequest());
  916.         }
  918.         $fieldDescription->setAssociationAdmin($admin);
  919.     }
  921.     /**
  922.      * @param string|int|null $id
  923.      *
  924.      * @phpstan-return T|null
  925.      */
  926.     final public function getObject($id): ?object
  927.     {
  928.         if (null === $id) {
  929.             return null;
  930.         }
  932.         $object = $this->getModelManager()->find($this->getClass(), $id);
  933.         if (null === $object) {
  934.             return null;
  935.         }
  937.         $this->alterObject($object);
  938.         foreach ($this->getExtensions() as $extension) {
  939.             $extension->alterObject($this, $object);
  940.         }
  942.         return $object;
  943.     }
  945.     final public function getForm(): FormInterface
  946.     {
  947.         $form = $this->buildForm();
  948.         if (null === $form) {
  949.             throw new \LogicException('Cannot access form during the building process.');
  950.         }
  952.         return $form;
  953.     }
  955.     final public function getList(): FieldDescriptionCollection
  956.     {
  957.         $list = $this->buildList();
  958.         if (null === $list) {
  959.             throw new \LogicException('Cannot access list during the building process.');
  960.         }
  962.         return $list;
  963.     }
  965.     final public function createQuery(): ProxyQueryInterface
  966.     {
  967.         $query = $this->getModelManager()->createQuery($this->getClass());
  969.         $query = $this->configureQuery($query);
  970.         foreach ($this->getExtensions() as $extension) {
  971.             $extension->configureQuery($this, $query);
  972.         }
  974.         return $query;
  975.     }
  977.     final public function getDatagrid(): DatagridInterface
  978.     {
  979.         $datagrid = $this->buildDatagrid();
  980.         if (null === $datagrid) {
  981.             throw new \LogicException('Cannot access datagrid during the building process.');
  982.         }
  984.         return $datagrid;
  985.     }
  987.     final public function getSideMenu(string $action, ?AdminInterface $childAdmin = null): ItemInterface
  988.     {
  989.         if ($this->isChild()) {
  990.             return $this->getParent()->getSideMenu($action, $this);
  991.         }
  993.         $menu = $this->buildTabMenu($action, $childAdmin);
  994.         if (null === $menu) {
  995.             throw new \LogicException('Cannot access menu during the building process.');
  996.         }
  998.         return $menu;
  999.     }
  1001.     final public function getRootCode(): string
  1002.     {
  1003.         return $this->getRoot()->getCode();
  1004.     }
  1006.     final public function getRoot(): AdminInterface
  1007.     {
  1008.         if (!$this->hasParentFieldDescription()) {
  1009.             return $this;
  1010.         }
  1012.         return $this->getParentFieldDescription()->getAdmin()->getRoot();
  1013.     }
  1015.     final public function setBaseControllerName(string $baseControllerName): void
  1016.     {
  1017.         $this->baseControllerName = $baseControllerName;
  1018.     }
  1020.     final public function getBaseControllerName(): string
  1021.     {
  1022.         return $this->baseControllerName;
  1023.     }
  1025.     final public function getMaxPerPage(): int
  1026.     {
  1027.         $sortValues = $this->getDefaultSortValues();
  1029.         return $sortValues[DatagridInterface::PER_PAGE] ?? self::DEFAULT_LIST_PER_PAGE_RESULTS;
  1030.     }
  1032.     final public function setMaxPageLinks(int $maxPageLinks): void
  1033.     {
  1034.         $this->maxPageLinks = $maxPageLinks;
  1035.     }
  1037.     final public function getMaxPageLinks(): int
  1038.     {
  1039.         return $this->maxPageLinks;
  1040.     }
  1042.     final public function getFormGroups(): array
  1043.     {
  1044.         return $this->formGroups;
  1045.     }
  1047.     final public function setFormGroups(array $formGroups): void
  1048.     {
  1049.         $this->formGroups = $formGroups;
  1050.     }
  1052.     final public function removeFieldFromFormGroup(string $key): void
  1053.     {
  1054.         foreach ($this->formGroups as $name => $_formGroup) {
  1055.             unset($this->formGroups[$name]['fields'][$key]);
  1057.             if ([] === $this->formGroups[$name]['fields']) {
  1058.                 unset($this->formGroups[$name]);
  1059.             }
  1060.         }
  1061.     }
  1063.     final public function reorderFormGroup(string $group, array $keys): void
  1064.     {
  1065.         $formGroups = $this->getFormGroups();
  1066.         $formGroups[$group]['fields'] = array_merge(array_flip($keys), $formGroups[$group]['fields']);
  1067.         $this->setFormGroups($formGroups);
  1068.     }
  1070.     final public function getFormTabs(): array
  1071.     {
  1072.         return $this->formTabs;
  1073.     }
  1075.     final public function setFormTabs(array $formTabs): void
  1076.     {
  1077.         $this->formTabs = $formTabs;
  1078.     }
  1080.     final public function getShowTabs(): array
  1081.     {
  1082.         return $this->showTabs;
  1083.     }
  1085.     final public function setShowTabs(array $showTabs): void
  1086.     {
  1087.         $this->showTabs = $showTabs;
  1088.     }
  1090.     final public function getShowGroups(): array
  1091.     {
  1092.         return $this->showGroups;
  1093.     }
  1095.     final public function setShowGroups(array $showGroups): void
  1096.     {
  1097.         $this->showGroups = $showGroups;
  1098.     }
  1100.     final public function removeFieldFromShowGroup(string $key): void
  1101.     {
  1102.         foreach ($this->showGroups as $name => $_showGroup) {
  1103.             unset($this->showGroups[$name]['fields'][$key]);
  1105.             if ([] === $this->showGroups[$name]['fields']) {
  1106.                 unset($this->showGroups[$name]);
  1107.             }
  1108.         }
  1109.     }
  1111.     final public function reorderShowGroup(string $group, array $keys): void
  1112.     {
  1113.         $showGroups = $this->getShowGroups();
  1114.         $showGroups[$group]['fields'] = array_merge(array_flip($keys), $showGroups[$group]['fields']);
  1115.         $this->setShowGroups($showGroups);
  1116.     }
  1118.     final public function setParentFieldDescription(FieldDescriptionInterface $parentFieldDescription): void
  1119.     {
  1120.         $this->parentFieldDescription = $parentFieldDescription;
  1121.     }
  1123.     final public function getParentFieldDescription(): FieldDescriptionInterface
  1124.     {
  1125.         if (!$this->hasParentFieldDescription()) {
  1126.             throw new \LogicException(sprintf(
  1127.                 'Admin "%s" has no parent field description.',
  1128.                 static::class
  1129.             ));
  1130.         }
  1131.         \assert(null !== $this->parentFieldDescription);
  1133.         return $this->parentFieldDescription;
  1134.     }
  1136.     final public function hasParentFieldDescription(): bool
  1137.     {
  1138.         return $this->parentFieldDescription instanceof FieldDescriptionInterface;
  1139.     }
  1141.     final public function setSubject(?object $subject): void
  1142.     {
  1143.         if (null !== $subject && !is_a($subject, $this->getClass(), true)) {
  1144.             throw new \LogicException(sprintf(
  1145.                 'Admin "%s" does not allow this subject: %s, use the one register with this admin class %s',
  1146.                 static::class,
  1147.                 \get_class($subject),
  1148.                 $this->getClass()
  1149.             ));
  1150.         }
  1152.         $this->subject = $subject;
  1153.     }
  1155.     final public function getSubject(): object
  1156.     {
  1157.         if (!$this->hasSubject()) {
  1158.             throw new \LogicException(sprintf(
  1159.                 'Admin "%s" has no subject.',
  1160.                 static::class
  1161.             ));
  1162.         }
  1163.         \assert(null !== $this->subject);
  1165.         return $this->subject;
  1166.     }
  1168.     final public function hasSubject(): bool
  1169.     {
  1170.         if (null === $this->subject && $this->hasRequest() && !$this->hasParentFieldDescription()) {
  1171.             $id = $this->getRequest()->get($this->getIdParameter());
  1173.             if (null !== $id) {
  1174.                 $this->subject = $this->getObject($id);
  1175.             }
  1176.         }
  1178.         return null !== $this->subject;
  1179.     }
  1181.     final public function getFormFieldDescriptions(): array
  1182.     {
  1183.         $this->buildForm();
  1185.         return $this->formFieldDescriptions;
  1186.     }
  1188.     final public function getFormFieldDescription(string $name): FieldDescriptionInterface
  1189.     {
  1190.         $this->buildForm();
  1192.         if (!$this->hasFormFieldDescription($name)) {
  1193.             throw new \LogicException(sprintf(
  1194.                 'Admin "%s" has no form field description for the field %s.',
  1195.                 static::class,
  1196.                 $name
  1197.             ));
  1198.         }
  1200.         return $this->formFieldDescriptions[$name];
  1201.     }
  1203.     /**
  1204.      * Returns true if the admin has a FieldDescription with the given $name.
  1205.      */
  1206.     final public function hasFormFieldDescription(string $name): bool
  1207.     {
  1208.         $this->buildForm();
  1210.         return \array_key_exists($name, $this->formFieldDescriptions);
  1211.     }
  1213.     final public function addFormFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1214.     {
  1215.         $this->formFieldDescriptions[$name] = $fieldDescription;
  1216.     }
  1218.     /**
  1219.      * remove a FieldDescription.
  1220.      */
  1221.     final public function removeFormFieldDescription(string $name): void
  1222.     {
  1223.         unset($this->formFieldDescriptions[$name]);
  1224.     }
  1226.     /**
  1227.      * build and return the collection of form FieldDescription.
  1228.      *
  1229.      * @return FieldDescriptionInterface[] collection of form FieldDescription
  1230.      */
  1231.     final public function getShowFieldDescriptions(): array
  1232.     {
  1233.         $this->buildShow();
  1235.         return $this->showFieldDescriptions;
  1236.     }
  1238.     /**
  1239.      * Returns the form FieldDescription with the given $name.
  1240.      */
  1241.     final public function getShowFieldDescription(string $name): FieldDescriptionInterface
  1242.     {
  1243.         $this->buildShow();
  1245.         if (!$this->hasShowFieldDescription($name)) {
  1246.             throw new \LogicException(sprintf(
  1247.                 'Admin "%s" has no show field description for the field %s.',
  1248.                 static::class,
  1249.                 $name
  1250.             ));
  1251.         }
  1253.         return $this->showFieldDescriptions[$name];
  1254.     }
  1256.     final public function hasShowFieldDescription(string $name): bool
  1257.     {
  1258.         $this->buildShow();
  1260.         return \array_key_exists($name, $this->showFieldDescriptions);
  1261.     }
  1263.     final public function addShowFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1264.     {
  1265.         $this->showFieldDescriptions[$name] = $fieldDescription;
  1266.     }
  1268.     final public function removeShowFieldDescription(string $name): void
  1269.     {
  1270.         unset($this->showFieldDescriptions[$name]);
  1271.     }
  1273.     final public function getListFieldDescriptions(): array
  1274.     {
  1275.         $this->buildList();
  1277.         return $this->listFieldDescriptions;
  1278.     }
  1280.     final public function getListFieldDescription(string $name): FieldDescriptionInterface
  1281.     {
  1282.         $this->buildList();
  1284.         if (!$this->hasListFieldDescription($name)) {
  1285.             throw new \LogicException(sprintf(
  1286.                 'Admin "%s" has no list field description for %s.',
  1287.                 static::class,
  1288.                 $name
  1289.             ));
  1290.         }
  1292.         return $this->listFieldDescriptions[$name];
  1293.     }
  1295.     final public function hasListFieldDescription(string $name): bool
  1296.     {
  1297.         $this->buildList();
  1299.         return \array_key_exists($name, $this->listFieldDescriptions);
  1300.     }
  1302.     final public function addListFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1303.     {
  1304.         $this->listFieldDescriptions[$name] = $fieldDescription;
  1305.     }
  1307.     final public function removeListFieldDescription(string $name): void
  1308.     {
  1309.         unset($this->listFieldDescriptions[$name]);
  1310.     }
  1312.     final public function getFilterFieldDescription(string $name): FieldDescriptionInterface
  1313.     {
  1314.         $this->buildDatagrid();
  1316.         if (!$this->hasFilterFieldDescription($name)) {
  1317.             throw new \LogicException(sprintf(
  1318.                 'Admin "%s" has no filter field description for the field %s.',
  1319.                 static::class,
  1320.                 $name
  1321.             ));
  1322.         }
  1324.         return $this->filterFieldDescriptions[$name];
  1325.     }
  1327.     final public function hasFilterFieldDescription(string $name): bool
  1328.     {
  1329.         $this->buildDatagrid();
  1331.         return \array_key_exists($name, $this->filterFieldDescriptions);
  1332.     }
  1334.     final public function addFilterFieldDescription(string $name, FieldDescriptionInterface $fieldDescription): void
  1335.     {
  1336.         $this->filterFieldDescriptions[$name] = $fieldDescription;
  1337.     }
  1339.     final public function removeFilterFieldDescription(string $name): void
  1340.     {
  1341.         unset($this->filterFieldDescriptions[$name]);
  1342.     }
  1344.     final public function getFilterFieldDescriptions(): array
  1345.     {
  1346.         $this->buildDatagrid();
  1348.         return $this->filterFieldDescriptions;
  1349.     }
  1351.     final public function addChild(AdminInterface $child, string $field): void
  1352.     {
  1353.         $parentAdmin = $this;
  1354.         while ($parentAdmin->isChild() && $parentAdmin->getCode() !== $child->getCode()) {
  1355.             $parentAdmin = $parentAdmin->getParent();
  1356.         }
  1358.         if ($parentAdmin->getCode() === $child->getCode()) {
  1359.             throw new \LogicException(sprintf(
  1360.                 'Circular reference detected! The child admin `%s` is already in the parent tree of the `%s` admin.',
  1361.                 $child->getCode(),
  1362.                 $this->getCode()
  1363.             ));
  1364.         }
  1366.         $this->children[$child->getCode()] = $child;
  1368.         $child->setParent($this, $field);
  1369.     }
  1371.     final public function hasChild(string $code): bool
  1372.     {
  1373.         return isset($this->children[$code]);
  1374.     }
  1376.     final public function getChildren(): array
  1377.     {
  1378.         return $this->children;
  1379.     }
  1381.     final public function getChild(string $code): AdminInterface
  1382.     {
  1383.         if (!$this->hasChild($code)) {
  1384.             throw new \LogicException(sprintf(
  1385.                 'Admin "%s" has no child for the code %s.',
  1386.                 static::class,
  1387.                 $code
  1388.             ));
  1389.         }
  1391.         return $this->getChildren()[$code];
  1392.     }
  1394.     final public function setParent(AdminInterface $parent, string $parentAssociationMapping): void
  1395.     {
  1396.         $this->parent = $parent;
  1397.         $this->parentAssociationMapping[$parent->getCode()] = $parentAssociationMapping;
  1398.     }
  1400.     final public function getParent(): AdminInterface
  1401.     {
  1402.         if (null === $this->parent) {
  1403.             throw new \LogicException(sprintf(
  1404.                 'Admin "%s" has no parent.',
  1405.                 static::class
  1406.             ));
  1407.         }
  1409.         return $this->parent;
  1410.     }
  1412.     final public function getRootAncestor(): AdminInterface
  1413.     {
  1414.         $parent = $this;
  1416.         while ($parent->isChild()) {
  1417.             $parent = $parent->getParent();
  1418.         }
  1420.         return $parent;
  1421.     }
  1423.     final public function getChildDepth(): int
  1424.     {
  1425.         $parent = $this;
  1426.         $depth = 0;
  1428.         while ($parent->isChild()) {
  1429.             $parent = $parent->getParent();
  1430.             ++$depth;
  1431.         }
  1433.         return $depth;
  1434.     }
  1436.     final public function getCurrentLeafChildAdmin(): ?AdminInterface
  1437.     {
  1438.         $child = $this->getCurrentChildAdmin();
  1440.         if (null === $child) {
  1441.             return null;
  1442.         }
  1444.         for ($c = $child; null !== $c; $c = $child->getCurrentChildAdmin()) {
  1445.             $child = $c;
  1446.         }
  1448.         return $child;
  1449.     }
  1451.     final public function isChild(): bool
  1452.     {
  1453.         return $this->parent instanceof AdminInterface;
  1454.     }
  1456.     /**
  1457.      * Returns true if the admin has children, false otherwise.
  1458.      */
  1459.     final public function hasChildren(): bool
  1460.     {
  1461.         return \count($this->children) > 0;
  1462.     }
  1464.     final public function setUniqId(string $uniqId): void
  1465.     {
  1466.         $this->uniqId = $uniqId;
  1467.     }
  1469.     final public function getUniqId(): string
  1470.     {
  1471.         if (null === $this->uniqId) {
  1472.             $this->uniqId = sprintf('s%s', uniqid());
  1473.         }
  1475.         return $this->uniqId;
  1476.     }
  1478.     final public function getClassnameLabel(): string
  1479.     {
  1480.         if (null === $this->classnameLabel) {
  1481.             throw new \LogicException(sprintf(
  1482.                 'Admin "%s" has no classname label. Did you forgot to initialize the admin ?',
  1483.                 static::class
  1484.             ));
  1485.         }
  1487.         return $this->classnameLabel;
  1488.     }
  1490.     final public function getPersistentParameters(): array
  1491.     {
  1492.         $parameters = $this->configurePersistentParameters();
  1493.         foreach ($this->getExtensions() as $extension) {
  1494.             $parameters = $extension->configurePersistentParameters($this, $parameters);
  1495.         }
  1497.         return $parameters;
  1498.     }
  1500.     final public function getPersistentParameter(string $name, $default = null)
  1501.     {
  1502.         $parameters = $this->getPersistentParameters();
  1504.         return $parameters[$name] ?? $default;
  1505.     }
  1507.     final public function setCurrentChild(bool $currentChild): void
  1508.     {
  1509.         $this->currentChild = $currentChild;
  1510.     }
  1512.     final public function isCurrentChild(): bool
  1513.     {
  1514.         return $this->currentChild;
  1515.     }
  1517.     final public function getCurrentChildAdmin(): ?AdminInterface
  1518.     {
  1519.         foreach ($this->getChildren() as $child) {
  1520.             if ($child->isCurrentChild()) {
  1521.                 return $child;
  1522.             }
  1523.         }
  1525.         return null;
  1526.     }
  1528.     final public function setTranslationDomain(string $translationDomain): void
  1529.     {
  1530.         $this->translationDomain = $translationDomain;
  1531.     }
  1533.     final public function getTranslationDomain(): string
  1534.     {
  1535.         return $this->translationDomain;
  1536.     }
  1538.     final public function getTranslationLabel(string $label, string $context = '', string $type = ''): string
  1539.     {
  1540.         return $this->getLabelTranslatorStrategy()->getLabel($label, $context, $type);
  1541.     }
  1543.     final public function setRequest(Request $request): void
  1544.     {
  1545.         $this->request = $request;
  1547.         foreach ($this->getChildren() as $children) {
  1548.             $children->setRequest($request);
  1549.         }
  1550.     }
  1552.     final public function getRequest(): Request
  1553.     {
  1554.         if (null === $this->request) {
  1555.             throw new \LogicException('The Request object has not been set');
  1556.         }
  1558.         return $this->request;
  1559.     }
  1561.     final public function hasRequest(): bool
  1562.     {
  1563.         return null !== $this->request;
  1564.     }
  1566.     final public function getCode(): string
  1567.     {
  1568.         return $this->code;
  1569.     }
  1571.     final public function getBaseCodeRoute(): string
  1572.     {
  1573.         if ($this->isChild()) {
  1574.             return $this->getParent()->getBaseCodeRoute().'|'.$this->getCode();
  1575.         }
  1577.         return $this->getCode();
  1578.     }
  1580.     /**
  1581.      * @return string
  1582.      */
  1583.     public function getObjectIdentifier()
  1584.     {
  1585.         return $this->getCode();
  1586.     }
  1588.     public function showInDashboard(): bool
  1589.     {
  1590.         // NEXT_MAJOR: Remove those lines and uncomment the last one.
  1591.         $permissionShow = $this->getPermissionsShow(self::CONTEXT_DASHBOARD, 'sonata_deprecation_mute');
  1592.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1594.         return $this->isGranted($permission);
  1595.         // return $this->isGranted('LIST');
  1596.     }
  1598.     /**
  1599.      * NEXT_MAJOR: Remove this method.
  1600.      *
  1601.      * @deprecated since sonata-project/admin-bundle version 4.7 use showInDashboard instead
  1602.      */
  1603.     final public function showIn(string $context): bool
  1604.     {
  1605.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  1606.             @trigger_error(sprintf(
  1607.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  1608.                 .' removed in 5.0 version. Use showInDashboard() instead.',
  1609.                 __METHOD__
  1610.             ), \E_USER_DEPRECATED);
  1611.         }
  1613.         $permissionShow = $this->getPermissionsShow($context, 'sonata_deprecation_mute');
  1614.         // Avoid isGranted deprecation if there is only one permission show.
  1615.         $permission = 1 === \count($permissionShow) ? reset($permissionShow) : $permissionShow;
  1617.         return $this->isGranted($permission);
  1618.     }
  1620.     final public function createObjectSecurity(object $object): void
  1621.     {
  1622.         $this->getSecurityHandler()->createObjectSecurity($this, $object);
  1623.     }
  1625.     final public function isGranted($name, ?object $object = null): bool
  1626.     {
  1627.         if (\is_array($name)) {
  1628.             @trigger_error(
  1629.                 sprintf(
  1630.                     'Passing an array as argument 1 of "%s()" is deprecated since sonata-project/admin-bundle 4.6'
  1631.                     .' and will throw an error in 5.0. You MUST pass a string instead.',
  1632.                     __METHOD__
  1633.                 ),
  1634.                 \E_USER_DEPRECATED
  1635.             );
  1636.         }
  1638.         $objectRef = null !== $object ? sprintf('/%s#%s', spl_object_hash($object), $this->id($object) ?? '') : '';
  1639.         $key = md5(json_encode($name).$objectRef);
  1641.         if (!\array_key_exists($key, $this->cacheIsGranted)) {
  1642.             $this->cacheIsGranted[$key] = $this->getSecurityHandler()->isGranted($this, $name, $object ?? $this);
  1643.         }
  1645.         return $this->cacheIsGranted[$key];
  1646.     }
  1648.     final public function getUrlSafeIdentifier(object $model): ?string
  1649.     {
  1650.         return $this->getModelManager()->getUrlSafeIdentifier($model);
  1651.     }
  1653.     final public function getNormalizedIdentifier(object $model): ?string
  1654.     {
  1655.         return $this->getModelManager()->getNormalizedIdentifier($model);
  1656.     }
  1658.     public function id(object $model): ?string
  1659.     {
  1660.         return $this->getNormalizedIdentifier($model);
  1661.     }
  1663.     final public function getShow(): FieldDescriptionCollection
  1664.     {
  1665.         $show = $this->buildShow();
  1666.         if (null === $show) {
  1667.             throw new \LogicException('Cannot access show during the building process.');
  1668.         }
  1670.         return $show;
  1671.     }
  1673.     final public function setFormTheme(array $formTheme): void
  1674.     {
  1675.         $this->formTheme = $formTheme;
  1676.     }
  1678.     final public function getFormTheme(): array
  1679.     {
  1680.         return $this->formTheme;
  1681.     }
  1683.     final public function setFilterTheme(array $filterTheme): void
  1684.     {
  1685.         $this->filterTheme = $filterTheme;
  1686.     }
  1688.     final public function getFilterTheme(): array
  1689.     {
  1690.         return $this->filterTheme;
  1691.     }
  1693.     final public function addExtension(AdminExtensionInterface $extension): void
  1694.     {
  1695.         $this->extensions[] = $extension;
  1696.     }
  1698.     /**
  1699.      * @phpstan-param AdminExtensionInterface<T> $extension
  1700.      */
  1701.     final public function removeExtension(AdminExtensionInterface $extension): void
  1702.     {
  1703.         $key = array_search($extension, $this->extensions, true);
  1704.         if (false === $key) {
  1705.             throw new \InvalidArgumentException(
  1706.                 sprintf('The extension "%s" was not set to the "%s" admin.', \get_class($extension), __CLASS__)
  1707.             );
  1708.         }
  1710.         unset($this->extensions[$key]);
  1711.     }
  1713.     final public function getExtensions(): array
  1714.     {
  1715.         return $this->extensions;
  1716.     }
  1718.     public function toString(object $object): string
  1719.     {
  1720.         if (method_exists($object, '__toString') && null !== $object->__toString()) {
  1721.             return $object->__toString();
  1722.         }
  1724.         return sprintf('%s:%s', ClassUtils::getClass($object), spl_object_hash($object));
  1725.     }
  1727.     final public function supportsPreviewMode(): bool
  1728.     {
  1729.         return $this->supportsPreviewMode;
  1730.     }
  1732.     /**
  1733.      * Returns predefined per page options.
  1734.      *
  1735.      * @return list<int>
  1736.      */
  1737.     public function getPerPageOptions(): array
  1738.     {
  1739.         $perPageOptions = self::DEFAULT_LIST_PER_PAGE_OPTIONS;
  1740.         $perPageOptions[] = $this->getMaxPerPage();
  1742.         $perPageOptions = array_unique($perPageOptions);
  1743.         sort($perPageOptions);
  1745.         return $perPageOptions;
  1746.     }
  1748.     /**
  1749.      * Returns true if the per page value is allowed, false otherwise.
  1750.      */
  1751.     final public function determinedPerPageValue(int $perPage): bool
  1752.     {
  1753.         return \in_array($perPage, $this->getPerPageOptions(), true);
  1754.     }
  1756.     final public function isAclEnabled(): bool
  1757.     {
  1758.         return $this->getSecurityHandler() instanceof AclSecurityHandlerInterface;
  1759.     }
  1761.     public function getObjectMetadata(object $object): MetadataInterface
  1762.     {
  1763.         return new Metadata($this->toString($object));
  1764.     }
  1766.     final public function setListMode(string $mode): void
  1767.     {
  1768.         $this->getRequest()->getSession()->set(sprintf('%s.list_mode', $this->getCode()), $mode);
  1769.     }
  1771.     final public function getListMode(): string
  1772.     {
  1773.         if (!$this->hasRequest() || !$this->getRequest()->hasSession()) {
  1774.             return 'list';
  1775.         }
  1777.         return $this->getRequest()->getSession()->get(sprintf('%s.list_mode', $this->getCode()), 'list');
  1778.     }
  1780.     final public function checkAccess(string $action, ?object $object = null): void
  1781.     {
  1782.         $access = $this->getAccess();
  1784.         if (!\array_key_exists($action, $access)) {
  1785.             throw new \InvalidArgumentException(sprintf(
  1786.                 'Action "%s" could not be found in access mapping.'
  1787.                 .' Please make sure your action is defined into your admin class accessMapping property.',
  1788.                 $action
  1789.             ));
  1790.         }
  1792.         if (!\is_array($access[$action])) {
  1793.             $access[$action] = [$access[$action]];
  1794.         }
  1796.         foreach ($access[$action] as $role) {
  1797.             if (false === $this->isGranted($role, $object)) {
  1798.                 throw new AccessDeniedException(sprintf('Access Denied to the action %s and role %s', $action, $role));
  1799.             }
  1800.         }
  1801.     }
  1803.     final public function hasAccess(string $action, ?object $object = null): bool
  1804.     {
  1805.         $access = $this->getAccess();
  1807.         if (!\array_key_exists($action, $access)) {
  1808.             return false;
  1809.         }
  1811.         if (!\is_array($access[$action])) {
  1812.             $access[$action] = [$access[$action]];
  1813.         }
  1815.         foreach ($access[$action] as $role) {
  1816.             if (false === $this->isGranted($role, $object)) {
  1817.                 return false;
  1818.             }
  1819.         }
  1821.         return true;
  1822.     }
  1824.     /**
  1825.      * @return array<string, array<string, mixed>>
  1826.      *
  1827.      * @phpstan-param T|null $object
  1828.      */
  1829.     final public function getActionButtons(string $action, ?object $object = null): array
  1830.     {
  1831.         $defaultButtonList = $this->getDefaultActionButtons($action, $object);
  1832.         $buttonList = $this->configureActionButtons($defaultButtonList, $action, $object);
  1834.         foreach ($this->getExtensions() as $extension) {
  1835.             $buttonList = $extension->configureActionButtons($this, $buttonList, $action, $object);
  1836.         }
  1838.         return $buttonList;
  1839.     }
  1841.     /**
  1842.      * Get the list of actions that can be accessed directly from the dashboard.
  1843.      *
  1844.      * @return array<string, array<string, mixed>>
  1845.      */
  1846.     final public function getDashboardActions(): array
  1847.     {
  1848.         $actions = [];
  1850.         if ($this->hasRoute('create') && $this->hasAccess('create')) {
  1851.             $actions['create'] = [
  1852.                 'label' => 'link_add',
  1853.                 'translation_domain' => 'SonataAdminBundle',
  1854.                 'template' => $this->getTemplateRegistry()->getTemplate('action_create'),
  1855.                 'url' => $this->generateUrl('create'),
  1856.                 'icon' => 'fas fa-plus-circle',
  1857.             ];
  1858.         }
  1860.         if ($this->hasRoute('list') && $this->hasAccess('list')) {
  1861.             $actions['list'] = [
  1862.                 'label' => 'link_list',
  1863.                 'translation_domain' => 'SonataAdminBundle',
  1864.                 'url' => $this->generateUrl('list'),
  1865.                 'icon' => 'fas fa-list',
  1866.             ];
  1867.         }
  1869.         $actions = $this->configureDashboardActions($actions);
  1871.         foreach ($this->getExtensions() as $extension) {
  1872.             $actions = $extension->configureDashboardActions($this, $actions);
  1873.         }
  1875.         return $actions;
  1876.     }
  1878.     final public function createFieldDescription(string $propertyName, array $options = []): FieldDescriptionInterface
  1879.     {
  1880.         $fieldDescriptionFactory = $this->getFieldDescriptionFactory();
  1882.         $fieldDescription = $fieldDescriptionFactory->create($this->getClass(), $propertyName, $options);
  1884.         $fieldDescription->setAdmin($this);
  1886.         return $fieldDescription;
  1887.     }
  1889.     /**
  1890.      * Hook to run after initialization.
  1891.      */
  1892.     protected function configure(): void
  1893.     {
  1894.     }
  1896.     /**
  1897.      * @phpstan-return T
  1898.      */
  1899.     protected function createNewInstance(): object
  1900.     {
  1901.         $object = Instantiator::instantiate($this->getClass());
  1902.         $this->appendParentObject($object);
  1904.         return $object;
  1905.     }
  1907.     /**
  1908.      * @phpstan-param T $object
  1909.      */
  1910.     protected function alterNewInstance(object $object): void
  1911.     {
  1912.     }
  1914.     /**
  1915.      * @phpstan-param T $object
  1916.      */
  1917.     protected function alterObject(object $object): void
  1918.     {
  1919.     }
  1921.     /**
  1922.      * @phpstan-param T $object
  1923.      */
  1924.     protected function preValidate(object $object): void
  1925.     {
  1926.     }
  1928.     /**
  1929.      * @phpstan-param T $object
  1930.      */
  1931.     protected function preUpdate(object $object): void
  1932.     {
  1933.     }
  1935.     /**
  1936.      * @phpstan-param T $object
  1937.      */
  1938.     protected function postUpdate(object $object): void
  1939.     {
  1940.     }
  1942.     /**
  1943.      * @phpstan-param T $object
  1944.      */
  1945.     protected function prePersist(object $object): void
  1946.     {
  1947.     }
  1949.     /**
  1950.      * @phpstan-param T $object
  1951.      */
  1952.     protected function postPersist(object $object): void
  1953.     {
  1954.     }
  1956.     /**
  1957.      * @phpstan-param T $object
  1958.      */
  1959.     protected function preRemove(object $object): void
  1960.     {
  1961.     }
  1963.     /**
  1964.      * @phpstan-param T $object
  1965.      */
  1966.     protected function postRemove(object $object): void
  1967.     {
  1968.     }
  1970.     /**
  1971.      * @return array<string, mixed>
  1972.      */
  1973.     protected function configurePersistentParameters(): array
  1974.     {
  1975.         return [];
  1976.     }
  1978.     /**
  1979.      * @return string[]
  1980.      */
  1981.     protected function configureExportFields(): array
  1982.     {
  1983.         return $this->getModelManager()->getExportFields($this->getClass());
  1984.     }
  1986.     protected function configureQuery(ProxyQueryInterface $query): ProxyQueryInterface
  1987.     {
  1988.         return $query;
  1989.     }
  1991.     /**
  1992.      * urlize the given word.
  1993.      *
  1994.      * @param string $sep the separator
  1995.      */
  1996.     final protected function urlize(string $word, string $sep = '_'): string
  1997.     {
  1998.         return strtolower(preg_replace('/[^a-z0-9_]/i', $sep.'$1', $word) ?? '');
  1999.     }
  2001.     /**
  2002.      * @param array<string, mixed> $parameters
  2003.      *
  2004.      * @return array<string, mixed>
  2005.      */
  2006.     protected function configureFilterParameters(array $parameters): array
  2007.     {
  2008.         return $parameters;
  2009.     }
  2011.     /**
  2012.      * Returns a list of default sort values.
  2013.      *
  2014.      * @phpstan-return array{
  2015.      *     _page?: int,
  2016.      *     _per_page?: int,
  2017.      *     _sort_by?: string,
  2018.      *     _sort_order?: string
  2019.      * }
  2020.      */
  2021.     final protected function getDefaultSortValues(): array
  2022.     {
  2023.         $defaultSortValues = [DatagridInterface::PAGE => 1, DatagridInterface::PER_PAGE => self::DEFAULT_LIST_PER_PAGE_RESULTS];
  2025.         $this->configureDefaultSortValues($defaultSortValues);
  2027.         foreach ($this->getExtensions() as $extension) {
  2028.             $extension->configureDefaultSortValues($this, $defaultSortValues);
  2029.         }
  2031.         return $defaultSortValues;
  2032.     }
  2034.     /**
  2035.      * Returns a list of default filters.
  2036.      *
  2037.      * @return array<string, array<string, mixed>>
  2038.      */
  2039.     final protected function getDefaultFilterValues(): array
  2040.     {
  2041.         $defaultFilterValues = [];
  2043.         $this->configureDefaultFilterValues($defaultFilterValues);
  2045.         foreach ($this->getExtensions() as $extension) {
  2046.             $extension->configureDefaultFilterValues($this, $defaultFilterValues);
  2047.         }
  2049.         return $defaultFilterValues;
  2050.     }
  2052.     /**
  2053.      * @return array<string, mixed>
  2054.      */
  2055.     final protected function getFormOptions(): array
  2056.     {
  2057.         $formOptions = [];
  2059.         $this->configureFormOptions($formOptions);
  2061.         foreach ($this->getExtensions() as $extension) {
  2062.             $extension->configureFormOptions($this, $formOptions);
  2063.         }
  2065.         return $formOptions;
  2066.     }
  2068.     /**
  2069.      * @phpstan-param FormMapper<T> $form
  2070.      */
  2071.     protected function configureFormFields(FormMapper $form): void
  2072.     {
  2073.     }
  2075.     /**
  2076.      * @phpstan-param ListMapper<T> $list
  2077.      */
  2078.     protected function configureListFields(ListMapper $list): void
  2079.     {
  2080.     }
  2082.     /**
  2083.      * @phpstan-param DatagridMapper<T> $filter
  2084.      */
  2085.     protected function configureDatagridFilters(DatagridMapper $filter): void
  2086.     {
  2087.     }
  2089.     /**
  2090.      * @phpstan-param ShowMapper<T> $show
  2091.      */
  2092.     protected function configureShowFields(ShowMapper $show): void
  2093.     {
  2094.     }
  2096.     protected function configureRoutes(RouteCollectionInterface $collection): void
  2097.     {
  2098.     }
  2100.     /**
  2101.      * @param array<string, array<string, mixed>> $buttonList
  2102.      *
  2103.      * @return array<string, array<string, mixed>>
  2104.      *
  2105.      * @phpstan-param T|null $object
  2106.      */
  2107.     protected function configureActionButtons(array $buttonList, string $action, ?object $object = null): array
  2108.     {
  2109.         return $buttonList;
  2110.     }
  2112.     /**
  2113.      * @param array<string, array<string, mixed>> $actions
  2114.      *
  2115.      * @return array<string, array<string, mixed>>
  2116.      */
  2117.     protected function configureDashboardActions(array $actions): array
  2118.     {
  2119.         return $actions;
  2120.     }
  2122.     /**
  2123.      * Allows you to customize batch actions.
  2124.      *
  2125.      * @param array<string, array<string, mixed>> $actions
  2126.      *
  2127.      * @return array<string, array<string, mixed>>
  2128.      */
  2129.     protected function configureBatchActions(array $actions): array
  2130.     {
  2131.         return $actions;
  2132.     }
  2134.     /**
  2135.      * Configures the tab menu in your admin.
  2136.      *
  2137.      * @phpstan-template TChild of object
  2138.      *
  2139.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2140.      */
  2141.     protected function configureTabMenu(ItemInterface $menu, string $action, ?AdminInterface $childAdmin = null): void
  2142.     {
  2143.     }
  2145.     /**
  2146.      * Gets the subclass corresponding to the given name.
  2147.      *
  2148.      * @phpstan-return class-string<T>
  2149.      */
  2150.     protected function getSubClass(string $name): string
  2151.     {
  2152.         if ($this->hasSubClass($name)) {
  2153.             return $this->subClasses[$name];
  2154.         }
  2156.         throw new \LogicException(sprintf('Unable to find the subclass `%s` for admin `%s`', $name, static::class));
  2157.     }
  2159.     /**
  2160.      * Return list routes with permissions name.
  2161.      *
  2162.      * @return array<string, string|string[]>
  2163.      */
  2164.     final protected function getAccess(): array
  2165.     {
  2166.         $access = array_merge([
  2167.             'acl' => AdminPermissionMap::PERMISSION_MASTER,
  2168.             'export' => AdminPermissionMap::PERMISSION_EXPORT,
  2169.             'historyCompareRevisions' => AdminPermissionMap::PERMISSION_HISTORY,
  2170.             'historyViewRevision' => AdminPermissionMap::PERMISSION_HISTORY,
  2171.             'history' => AdminPermissionMap::PERMISSION_HISTORY,
  2172.             'edit' => AdminPermissionMap::PERMISSION_EDIT,
  2173.             'show' => AdminPermissionMap::PERMISSION_VIEW,
  2174.             'create' => AdminPermissionMap::PERMISSION_CREATE,
  2175.             'delete' => AdminPermissionMap::PERMISSION_DELETE,
  2176.             'batchDelete' => AdminPermissionMap::PERMISSION_DELETE,
  2177.             'list' => AdminPermissionMap::PERMISSION_LIST,
  2178.         ], $this->getAccessMapping());
  2180.         foreach ($this->getExtensions() as $extension) {
  2181.             $access = array_merge($access, $extension->getAccessMapping($this));
  2182.         }
  2184.         return $access;
  2185.     }
  2187.     /**
  2188.      * @return array<string, string|string[]> [action1 => requiredRole1, action2 => [requiredRole2, requiredRole3]]
  2189.      */
  2190.     protected function getAccessMapping(): array
  2191.     {
  2192.         return [];
  2193.     }
  2195.     /**
  2196.      * Return the list of permissions the user should have in order to display the admin.
  2197.      *
  2198.      * NEXT_MAJOR: Remove this method.
  2199.      *
  2200.      * @deprecated since sonata-project/admin-bundle version 4.7
  2201.      *
  2202.      * @return string[]
  2203.      */
  2204.     protected function getPermissionsShow(string $context): array
  2205.     {
  2206.         if ('sonata_deprecation_mute' !== (\func_get_args()[1] ?? null)) {
  2207.             @trigger_error(sprintf(
  2208.                 'The "%s()" method is deprecated since sonata-project/admin-bundle version 4.7 and will be'
  2209.                 .' removed in 5.0 version.',
  2210.                 __METHOD__
  2211.             ), \E_USER_DEPRECATED);
  2212.         }
  2214.         return ['LIST'];
  2215.     }
  2217.     /**
  2218.      * Configures a list of default filters.
  2219.      *
  2220.      * @param array<string, array<string, mixed>> $filterValues
  2221.      */
  2222.     protected function configureDefaultFilterValues(array &$filterValues): void
  2223.     {
  2224.     }
  2226.     /**
  2227.      * Configures a list of form options.
  2228.      *
  2229.      * @param array<string, mixed> $formOptions
  2230.      */
  2231.     protected function configureFormOptions(array &$formOptions): void
  2232.     {
  2233.     }
  2235.     /**
  2236.      * Configures a list of default sort values.
  2237.      *
  2238.      * Example:
  2239.      *   $sortValues[DatagridInterface::SORT_BY] = 'foo'
  2240.      *   $sortValues[DatagridInterface::SORT_ORDER] = 'DESC'
  2241.      *
  2242.      * @param array<string, string|int> $sortValues
  2243.      * @phpstan-param array{
  2244.      *     _page?: int,
  2245.      *     _per_page?: int,
  2246.      *     _sort_by?: string,
  2247.      *     _sort_order?: string
  2248.      * } $sortValues
  2249.      */
  2250.     protected function configureDefaultSortValues(array &$sortValues): void
  2251.     {
  2252.     }
  2254.     /**
  2255.      * Set the parent object, if any, to the provided object.
  2256.      *
  2257.      * @phpstan-param T $object
  2258.      */
  2259.     final protected function appendParentObject(object $object): void
  2260.     {
  2261.         if ($this->isChild()) {
  2262.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2264.             if (null !== $parentAssociationMapping) {
  2265.                 $parentAdmin = $this->getParent();
  2266.                 $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2268.                 if (null !== $parentObject) {
  2269.                     $propertyAccessor = PropertyAccess::createPropertyAccessor();
  2270.                     $value = $propertyAccessor->getValue($object, $parentAssociationMapping);
  2272.                     if (\is_array($value) || $value instanceof \ArrayAccess) {
  2273.                         $value[] = $parentObject;
  2274.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $value);
  2275.                     } else {
  2276.                         $propertyAccessor->setValue($object, $parentAssociationMapping, $parentObject);
  2277.                     }
  2278.                 }
  2280.                 return;
  2281.             }
  2282.         }
  2284.         if ($this->hasParentFieldDescription()) {
  2285.             $parentAdmin = $this->getParentFieldDescription()->getAdmin();
  2286.             $parentObject = $parentAdmin->getObject($this->getRequest()->get($parentAdmin->getIdParameter()));
  2288.             if (null !== $parentObject) {
  2289.                 ObjectManipulator::setObject($object, $parentObject, $this->getParentFieldDescription());
  2290.             }
  2291.         }
  2292.     }
  2294.     /**
  2295.      * @return array<string, array<string, mixed>>
  2296.      *
  2297.      * @phpstan-param T|null $object
  2298.      */
  2299.     private function getDefaultActionButtons(string $action, ?object $object = null): array
  2300.     {
  2301.         // nothing to do for non-internal actions
  2302.         if (!isset(self::INTERNAL_ACTIONS[$action])) {
  2303.             return [];
  2304.         }
  2306.         $buttonList = [];
  2308.         $actionBit = self::INTERNAL_ACTIONS[$action];
  2310.         if (0 !== (self::MASK_OF_ACTION_CREATE & $actionBit)
  2311.             && $this->hasRoute('create')
  2312.             && $this->hasAccess('create')
  2313.         ) {
  2314.             $buttonList['create'] = [
  2315.                 'template' => $this->getTemplateRegistry()->getTemplate('button_create'),
  2316.             ];
  2317.         }
  2319.         $canAccessObject = 0 !== (self::MASK_OF_ACTIONS_USING_OBJECT & $actionBit)
  2320.             && null !== $object
  2321.             && null !== $this->id($object);
  2323.         if ($canAccessObject
  2324.             && 0 !== (self::MASK_OF_ACTION_EDIT & $actionBit)
  2325.             && $this->hasRoute('edit')
  2326.             && $this->hasAccess('edit', $object)
  2327.         ) {
  2328.             $buttonList['edit'] = [
  2329.                 'template' => $this->getTemplateRegistry()->getTemplate('button_edit'),
  2330.             ];
  2331.         }
  2333.         if ($canAccessObject
  2334.             && 0 !== (self::MASK_OF_ACTION_HISTORY & $actionBit)
  2335.             && $this->hasRoute('history')
  2336.             && $this->hasAccess('history', $object)
  2337.         ) {
  2338.             $buttonList['history'] = [
  2339.                 'template' => $this->getTemplateRegistry()->getTemplate('button_history'),
  2340.             ];
  2341.         }
  2343.         if ($canAccessObject
  2344.             && 0 !== (self::MASK_OF_ACTION_ACL & $actionBit)
  2345.             && $this->isAclEnabled()
  2346.             && $this->hasRoute('acl')
  2347.             && $this->hasAccess('acl', $object)
  2348.         ) {
  2349.             $buttonList['acl'] = [
  2350.                 'template' => $this->getTemplateRegistry()->getTemplate('button_acl'),
  2351.             ];
  2352.         }
  2354.         if ($canAccessObject
  2355.             && 0 !== (self::MASK_OF_ACTION_SHOW & $actionBit)
  2356.             && $this->hasRoute('show')
  2357.             && $this->hasAccess('show', $object)
  2358.             && \count($this->getShow()) > 0
  2359.         ) {
  2360.             $buttonList['show'] = [
  2361.                 'template' => $this->getTemplateRegistry()->getTemplate('button_show'),
  2362.             ];
  2363.         }
  2365.         if (0 !== (self::MASK_OF_ACTION_LIST & $actionBit)
  2366.             && $this->hasRoute('list')
  2367.             && $this->hasAccess('list')
  2368.         ) {
  2369.             $buttonList['list'] = [
  2370.                 'template' => $this->getTemplateRegistry()->getTemplate('button_list'),
  2371.             ];
  2372.         }
  2374.         return $buttonList;
  2375.     }
  2377.     /**
  2378.      * @return DatagridInterface<ProxyQueryInterface>|null
  2379.      */
  2380.     private function buildDatagrid(): ?DatagridInterface
  2381.     {
  2382.         if ($this->loaded['datagrid']) {
  2383.             return $this->datagrid;
  2384.         }
  2386.         $this->loaded['datagrid'] = true;
  2388.         $filterParameters = $this->getFilterParameters();
  2390.         // transform DatagridInterface::SORT_BY filter parameter from a string to a FieldDescriptionInterface for the datagrid.
  2391.         if (isset($filterParameters[DatagridInterface::SORT_BY]) && \is_string($filterParameters[DatagridInterface::SORT_BY])) {
  2392.             if ($this->hasListFieldDescription($filterParameters[DatagridInterface::SORT_BY])) {
  2393.                 $filterParameters[DatagridInterface::SORT_BY] = $this->getListFieldDescription($filterParameters[DatagridInterface::SORT_BY]);
  2394.             } else {
  2395.                 $filterParameters[DatagridInterface::SORT_BY] = $this->createFieldDescription(
  2396.                     $filterParameters[DatagridInterface::SORT_BY]
  2397.                 );
  2399.                 $this->getListBuilder()->buildField(null, $filterParameters[DatagridInterface::SORT_BY]);
  2400.             }
  2401.         }
  2403.         // initialize the datagrid
  2404.         $this->datagrid = $this->getDatagridBuilder()->getBaseDatagrid($this, $filterParameters);
  2406.         $this->datagrid->getPager()->setMaxPageLinks($this->getMaxPageLinks());
  2408.         $mapper = new DatagridMapper($this->getDatagridBuilder(), $this->datagrid, $this);
  2410.         // build the datagrid filter
  2411.         $this->configureDatagridFilters($mapper);
  2413.         // ok, try to limit to add parent filter
  2414.         if ($this->isChild()) {
  2415.             $parentAssociationMapping = $this->getParentAssociationMapping();
  2417.             if (null !== $parentAssociationMapping && !$mapper->has($parentAssociationMapping)) {
  2418.                 $mapper->add($parentAssociationMapping, null, [
  2419.                     'show_filter' => false,
  2420.                     'label' => false,
  2421.                     'field_type' => ModelHiddenType::class,
  2422.                     'field_options' => [
  2423.                         'model_manager' => $this->getModelManager(),
  2424.                     ],
  2425.                     'operator_type' => HiddenType::class,
  2426.                 ], [
  2427.                     'admin_code' => $this->getParent()->getCode(),
  2428.                 ]);
  2429.             }
  2430.         }
  2432.         foreach ($this->getExtensions() as $extension) {
  2433.             $extension->configureDatagridFilters($mapper);
  2434.         }
  2436.         return $this->datagrid;
  2437.     }
  2439.     /**
  2440.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2441.      */
  2442.     private function buildShow(): ?FieldDescriptionCollection
  2443.     {
  2444.         if ($this->loaded['show']) {
  2445.             return $this->show;
  2446.         }
  2448.         $this->loaded['show'] = true;
  2450.         $this->show = $this->getShowBuilder()->getBaseList();
  2451.         $mapper = new ShowMapper($this->getShowBuilder(), $this->show, $this);
  2453.         $this->configureShowFields($mapper);
  2455.         foreach ($this->getExtensions() as $extension) {
  2456.             $extension->configureShowFields($mapper);
  2457.         }
  2459.         return $this->show;
  2460.     }
  2462.     /**
  2463.      * @return FieldDescriptionCollection<FieldDescriptionInterface>|null
  2464.      */
  2465.     private function buildList(): ?FieldDescriptionCollection
  2466.     {
  2467.         if ($this->loaded['list']) {
  2468.             return $this->list;
  2469.         }
  2471.         $this->loaded['list'] = true;
  2473.         $this->list = $this->getListBuilder()->getBaseList();
  2474.         $mapper = new ListMapper($this->getListBuilder(), $this->list, $this);
  2476.         if (\count($this->getBatchActions()) > 0 && $this->hasRequest() && !$this->getRequest()->isXmlHttpRequest()) {
  2477.             $mapper->add(ListMapper::NAME_BATCH, ListMapper::TYPE_BATCH, [
  2478.                 'label' => 'batch',
  2479.                 'sortable' => false,
  2480.                 'virtual_field' => true,
  2481.                 'template' => $this->getTemplateRegistry()->getTemplate('batch'),
  2482.             ]);
  2483.         }
  2485.         $this->configureListFields($mapper);
  2487.         foreach ($this->getExtensions() as $extension) {
  2488.             $extension->configureListFields($mapper);
  2489.         }
  2491.         if ($this->hasRequest()
  2492.             && $this->getRequest()->isXmlHttpRequest()
  2493.             && $this->getRequest()->query->getBoolean('select', true) // NEXT_MAJOR: Change the default value to `false` in version 5
  2494.         ) {
  2495.             $mapper->add(ListMapper::NAME_SELECT, ListMapper::TYPE_SELECT, [
  2496.                 'label' => false,
  2497.                 'sortable' => false,
  2498.                 'virtual_field' => false,
  2499.                 'template' => $this->getTemplateRegistry()->getTemplate('select'),
  2500.             ]);
  2501.         }
  2503.         return $this->list;
  2504.     }
  2506.     private function buildForm(): ?FormInterface
  2507.     {
  2508.         if ($this->loaded['form']) {
  2509.             return $this->form;
  2510.         }
  2512.         $this->loaded['form'] = true;
  2514.         $formBuilder = $this->getFormBuilder();
  2515.         $formBuilder->addEventListener(FormEvents::POST_SUBMIT, function (FormEvent $event): void {
  2516.             /** @phpstan-var T $data */
  2517.             $data = $event->getData();
  2518.             $this->preValidate($data);
  2519.         }, 100);
  2521.         $this->form = $formBuilder->getForm();
  2523.         return $this->form;
  2524.     }
  2526.     private function buildRoutes(): ?RouteCollectionInterface
  2527.     {
  2528.         if ($this->loaded['routes']) {
  2529.             return $this->routes;
  2530.         }
  2532.         $this->loaded['routes'] = true;
  2534.         $routes = new RouteCollection(
  2535.             $this->getBaseCodeRoute(),
  2536.             $this->getBaseRouteName(),
  2537.             $this->getBaseRoutePattern(),
  2538.             $this->getBaseControllerName()
  2539.         );
  2541.         $this->getRouteBuilder()->build($this, $routes);
  2543.         $this->configureRoutes($routes);
  2545.         foreach ($this->getExtensions() as $extension) {
  2546.             $extension->configureRoutes($this, $routes);
  2547.         }
  2549.         $this->routes = $routes;
  2551.         return $this->routes;
  2552.     }
  2554.     /**
  2555.      * @phpstan-template TChild of object
  2556.      *
  2557.      * @phpstan-param AdminInterface<TChild>|null $childAdmin
  2558.      */
  2559.     private function buildTabMenu(string $action, ?AdminInterface $childAdmin = null): ?ItemInterface
  2560.     {
  2561.         if ($this->loaded['tab_menu']) {
  2562.             return $this->menu;
  2563.         }
  2565.         $this->loaded['tab_menu'] = true;
  2567.         $menu = $this->getMenuFactory()->createItem('root');
  2568.         $menu->setChildrenAttribute('class', 'nav navbar-nav');
  2569.         $menu->setExtra('translation_domain', $this->getTranslationDomain());
  2571.         $this->configureTabMenu($menu, $action, $childAdmin);
  2573.         foreach ($this->getExtensions() as $extension) {
  2574.             $extension->configureTabMenu($this, $menu, $action, $childAdmin);
  2575.         }
  2577.         $this->menu = $menu;
  2579.         return $this->menu;
  2580.     }
  2581. }