vendor/easycorp/easyadmin-bundle/src/Field/Configurator/AssociationConfigurator.php line 30

  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Field\Configurator;
  5. use Doctrine\ORM\EntityRepository;
  6. use Doctrine\ORM\PersistentCollection;
  7. use EasyCorp\Bundle\EasyAdminBundle\Collection\FieldCollection;
  8. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  9. use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
  10. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
  11. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\TextAlign;
  12. use EasyCorp\Bundle\EasyAdminBundle\Context\AdminContext;
  13. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Field\FieldConfiguratorInterface;
  14. use EasyCorp\Bundle\EasyAdminBundle\Dto\EntityDto;
  15. use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
  16. use EasyCorp\Bundle\EasyAdminBundle\Factory\ControllerFactory;
  17. use EasyCorp\Bundle\EasyAdminBundle\Factory\EntityFactory;
  18. use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
  19. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\CrudAutocompleteType;
  20. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\CrudFormType;
  21. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  22. use Symfony\Component\HttpFoundation\RequestStack;
  23. use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
  24. use Symfony\Component\PropertyAccess\PropertyAccessor;
  25. use function Symfony\Component\Translation\t;
  27. /**
  28.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  29.  */
  30. final class AssociationConfigurator implements FieldConfiguratorInterface
  31. {
  32.     private EntityFactory $entityFactory;
  33.     private AdminUrlGenerator $adminUrlGenerator;
  34.     private RequestStack $requestStack;
  35.     private ControllerFactory $controllerFactory;
  37.     public function __construct(EntityFactory $entityFactory, AdminUrlGenerator $adminUrlGenerator, RequestStack $requestStack, ControllerFactory $controllerFactory)
  38.     {
  39.         $this->entityFactory = $entityFactory;
  40.         $this->adminUrlGenerator = $adminUrlGenerator;
  41.         $this->requestStack = $requestStack;
  42.         $this->controllerFactory = $controllerFactory;
  43.     }
  45.     public function supports(FieldDto $field, EntityDto $entityDto): bool
  46.     {
  47.         return AssociationField::class === $field->getFieldFqcn();
  48.     }
  50.     public function configure(FieldDto $field, EntityDto $entityDto, AdminContext $context): void
  51.     {
  52.         $propertyName = $field->getProperty();
  53.         if (!$entityDto->isAssociation($propertyName)) {
  54.             throw new \RuntimeException(sprintf('The "%s" field is not a Doctrine association, so it cannot be used as an association field.', $propertyName));
  55.         }
  57.         $targetEntityFqcn = $field->getDoctrineMetadata()->get('targetEntity');
  58.         // the target CRUD controller can be NULL; in that case, field value doesn't link to the related entity
  59.         $targetCrudControllerFqcn = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER)
  60.             ?? $context->getCrudControllers()->findCrudFqcnByEntityFqcn($targetEntityFqcn);
  62.         if (true === $field->getCustomOption(AssociationField::OPTION_RENDER_AS_EMBEDDED_FORM)) {
  63.             if (false === $entityDto->isToOneAssociation($propertyName)) {
  64.                 throw new \RuntimeException(
  65.                     sprintf(
  66.                         'The "%s" association field of "%s" is a to-many association but it\'s trying to use the "renderAsEmbeddedForm()" option, which is only available for to-one associations. If you want to use a CRUD form to render to-many associations, use a CollectionField instead of the AssociationField.',
  67.                         $field->getProperty(),
  68.                         $context->getCrud()?->getControllerFqcn(),
  69.                     )
  70.                 );
  71.             }
  73.             if (null === $targetCrudControllerFqcn) {
  74.                 throw new \RuntimeException(
  75.                     sprintf(
  76.                         'The "%s" association field of "%s" wants to render its contents using an EasyAdmin CRUD form. However, no CRUD form was found related to this field. You can either create a CRUD controller for the entity "%s" or pass the CRUD controller to use as the first argument of the "renderAsEmbeddedForm()" method.',
  77.                         $field->getProperty(),
  78.                         $context->getCrud()?->getControllerFqcn(),
  79.                         $targetEntityFqcn
  80.                     )
  81.                 );
  82.             }
  84.             $this->configureCrudForm($field, $entityDto, $propertyName, $targetEntityFqcn, $targetCrudControllerFqcn);
  86.             return;
  87.         }
  89.         $field->setCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER, $targetCrudControllerFqcn);
  91.         if (AssociationField::WIDGET_AUTOCOMPLETE === $field->getCustomOption(AssociationField::OPTION_WIDGET)) {
  92.             $field->setFormTypeOption('attr.data-ea-widget', 'ea-autocomplete');
  93.         }
  95.         // check for embedded associations
  96.         $propertyNameParts = explode('.', $propertyName);
  97.         if (\count($propertyNameParts) > 1) {
  98.             // prepare starting class for association
  99.             $targetEntityFqcn = $entityDto->getPropertyMetadata($propertyNameParts[0])->get('targetEntity');
  100.             array_shift($propertyNameParts);
  101.             $metadata = $this->entityFactory->getEntityMetadata($targetEntityFqcn);
  103.             foreach ($propertyNameParts as $association) {
  104.                 if (!$metadata->hasAssociation($association)) {
  105.                     throw new \RuntimeException(sprintf('There is no association for the class "%s" with name "%s"', $targetEntityFqcn, $association));
  106.                 }
  108.                 // overwrite next class from association
  109.                 $targetEntityFqcn = $metadata->getAssociationTargetClass($association);
  111.                 // read next association metadata
  112.                 $metadata = $this->entityFactory->getEntityMetadata($targetEntityFqcn);
  113.             }
  115.             $accessor = new PropertyAccessor();
  116.             $targetCrudControllerFqcn = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER);
  118.             $field->setFormTypeOptionIfNotSet('class', $targetEntityFqcn);
  120.             try {
  121.                 $relatedEntityId = $accessor->getValue($entityDto->getInstance(), $propertyName.'.'.$metadata->getIdentifierFieldNames()[0]);
  122.                 $relatedEntityDto = $this->entityFactory->create($targetEntityFqcn, $relatedEntityId);
  124.                 $field->setCustomOption(AssociationField::OPTION_RELATED_URL, $this->generateLinkToAssociatedEntity($targetCrudControllerFqcn, $relatedEntityDto));
  125.                 $field->setFormattedValue($this->formatAsString($relatedEntityDto->getInstance(), $relatedEntityDto));
  126.             } catch (UnexpectedTypeException) {
  127.                 // this may crash if something in the tree is null, so just do nothing then
  128.             }
  129.         } else {
  130.             if ($entityDto->isToOneAssociation($propertyName)) {
  131.                 $this->configureToOneAssociation($field);
  132.             }
  134.             if ($entityDto->isToManyAssociation($propertyName)) {
  135.                 $this->configureToManyAssociation($field);
  136.             }
  137.         }
  139.         if (true === $field->getCustomOption(AssociationField::OPTION_AUTOCOMPLETE)) {
  140.             $targetCrudControllerFqcn = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER);
  141.             if (null === $targetCrudControllerFqcn) {
  142.                 throw new \RuntimeException(sprintf('The "%s" field cannot be autocompleted because it doesn\'t define the related CRUD controller FQCN with the "setCrudController()" method.', $field->getProperty()));
  143.             }
  145.             $field->setFormType(CrudAutocompleteType::class);
  146.             $autocompleteEndpointUrl = $this->adminUrlGenerator
  147.                 ->unsetAll()
  148.                 ->set('page', 1) // The autocomplete should always start on the first page
  149.                 ->setController($field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER))
  150.                 ->setAction('autocomplete')
  151.                 ->set(AssociationField::PARAM_AUTOCOMPLETE_CONTEXT, [
  152.                     EA::CRUD_CONTROLLER_FQCN => $context->getRequest()->query->get(EA::CRUD_CONTROLLER_FQCN),
  153.                     'propertyName' => $propertyName,
  154.                     'originatingPage' => $context->getCrud()->getCurrentPage(),
  155.                 ])
  156.                 ->generateUrl();
  158.             $field->setFormTypeOption('attr.data-ea-autocomplete-endpoint-url', $autocompleteEndpointUrl);
  159.         } else {
  160.             $field->setFormTypeOptionIfNotSet('query_builder', static function (EntityRepository $repository) use ($field) {
  161.                 // TODO: should this use `createIndexQueryBuilder` instead, so we get the default ordering etc.?
  162.                 // it would then be identical to the one used in autocomplete action, but it is a bit complex getting it in here
  163.                 $queryBuilder = $repository->createQueryBuilder('entity');
  164.                 if (null !== $queryBuilderCallable = $field->getCustomOption(AssociationField::OPTION_QUERY_BUILDER_CALLABLE)) {
  165.                     $queryBuilderCallable($queryBuilder);
  166.                 }
  168.                 return $queryBuilder;
  169.             });
  170.         }
  171.     }
  173.     private function configureToOneAssociation(FieldDto $field): void
  174.     {
  175.         $field->setCustomOption(AssociationField::OPTION_DOCTRINE_ASSOCIATION_TYPE, 'toOne');
  177.         if (false === $field->getFormTypeOption('required')) {
  178.             $field->setFormTypeOptionIfNotSet('attr.placeholder', t('label.form.empty_value', [], 'EasyAdminBundle'));
  179.         }
  181.         $targetEntityFqcn = $field->getDoctrineMetadata()->get('targetEntity');
  182.         $targetCrudControllerFqcn = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_CONTROLLER);
  184.         $targetEntityDto = null === $field->getValue()
  185.             ? $this->entityFactory->create($targetEntityFqcn)
  186.             : $this->entityFactory->createForEntityInstance($field->getValue());
  187.         $field->setFormTypeOptionIfNotSet('class', $targetEntityDto->getFqcn());
  189.         $field->setCustomOption(AssociationField::OPTION_RELATED_URL, $this->generateLinkToAssociatedEntity($targetCrudControllerFqcn, $targetEntityDto));
  191.         $field->setFormattedValue($this->formatAsString($field->getValue(), $targetEntityDto));
  192.     }
  194.     private function configureToManyAssociation(FieldDto $field): void
  195.     {
  196.         $field->setCustomOption(AssociationField::OPTION_DOCTRINE_ASSOCIATION_TYPE, 'toMany');
  198.         // associations different from *-to-one cannot be sorted
  199.         $field->setSortable(false);
  201.         $field->setFormTypeOptionIfNotSet('multiple', true);
  203.         /* @var PersistentCollection $collection */
  204.         $field->setFormTypeOptionIfNotSet('class', $field->getDoctrineMetadata()->get('targetEntity'));
  206.         if (null === $field->getTextAlign()) {
  207.             $field->setTextAlign(TextAlign::RIGHT);
  208.         }
  210.         $field->setFormattedValue($this->countNumElements($field->getValue()));
  211.     }
  213.     private function formatAsString($entityInstance, EntityDto $entityDto): ?string
  214.     {
  215.         if (null === $entityInstance) {
  216.             return null;
  217.         }
  219.         if (method_exists($entityInstance, '__toString')) {
  220.             return (string) $entityInstance;
  221.         }
  223.         if (null !== $primaryKeyValue = $entityDto->getPrimaryKeyValue()) {
  224.             return sprintf('%s #%s', $entityDto->getName(), $primaryKeyValue);
  225.         }
  227.         return $entityDto->getName();
  228.     }
  230.     private function generateLinkToAssociatedEntity(?string $crudController, EntityDto $entityDto): ?string
  231.     {
  232.         if (null === $crudController) {
  233.             return null;
  234.         }
  236.         // TODO: check if user has permission to see the related entity
  237.         return $this->adminUrlGenerator
  238.             ->setController($crudController)
  239.             ->setAction(Action::DETAIL)
  240.             ->setEntityId($entityDto->getPrimaryKeyValue())
  241.             ->unset(EA::MENU_INDEX)
  242.             ->unset(EA::SUBMENU_INDEX)
  243.             ->includeReferrer()
  244.             ->generateUrl();
  245.     }
  247.     private function countNumElements($collection): int
  248.     {
  249.         if (null === $collection) {
  250.             return 0;
  251.         }
  253.         if (is_countable($collection)) {
  254.             return \count($collection);
  255.         }
  257.         if ($collection instanceof \Traversable) {
  258.             return iterator_count($collection);
  259.         }
  261.         return 0;
  262.     }
  264.     private function configureCrudForm(FieldDto $field, EntityDto $entityDto, string $propertyName, string $targetEntityFqcn, string $targetCrudControllerFqcn): void
  265.     {
  266.         $field->setFormType(CrudFormType::class);
  267.         $propertyAccessor = new PropertyAccessor();
  269.         if (null === $entityDto->getInstance()) {
  270.             $associatedEntity = null;
  271.         } else {
  272.             $associatedEntity = $propertyAccessor->isReadable($entityDto->getInstance(), $propertyName)
  273.                 ? $propertyAccessor->getValue($entityDto->getInstance(), $propertyName)
  274.                 : null;
  275.         }
  277.         if (null === $associatedEntity) {
  278.             $targetCrudControllerAction = Action::NEW;
  279.             $targetCrudControllerPageName = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_NEW_PAGE_NAME) ?? Crud::PAGE_NEW;
  280.         } else {
  281.             $targetCrudControllerAction = Action::EDIT;
  282.             $targetCrudControllerPageName = $field->getCustomOption(AssociationField::OPTION_EMBEDDED_CRUD_FORM_EDIT_PAGE_NAME) ?? Crud::PAGE_EDIT;
  283.         }
  285.         $field->setFormTypeOption(
  286.             'entityDto',
  287.             $this->createEntityDto($targetEntityFqcn, $targetCrudControllerFqcn, $targetCrudControllerAction, $targetCrudControllerPageName),
  288.         );
  289.     }
  291.     private function createEntityDto(string $entityFqcn, string $crudControllerFqcn, string $crudControllerAction, string $crudControllerPageName): EntityDto
  292.     {
  293.         $entityDto = $this->entityFactory->create($entityFqcn);
  295.         $crudController = $this->controllerFactory->getCrudControllerInstance(
  296.             $crudControllerFqcn,
  297.             $crudControllerAction,
  298.             $this->requestStack->getMainRequest()
  299.         );
  301.         $fields = $crudController->configureFields($crudControllerPageName);
  303.         $this->entityFactory->processFields($entityDto, FieldCollection::new($fields));
  305.         return $entityDto;
  306.     }
  307. }