vendor/easycorp/easyadmin-bundle/src/Controller/AbstractCrudController.php line 117

  1. <?php
  3. namespace EasyCorp\Bundle\EasyAdminBundle\Controller;
  5. use Doctrine\DBAL\Exception\ForeignKeyConstraintViolationException;
  6. use Doctrine\ORM\EntityManagerInterface;
  7. use Doctrine\ORM\QueryBuilder;
  8. use Doctrine\Persistence\ManagerRegistry;
  9. use EasyCorp\Bundle\EasyAdminBundle\Collection\FieldCollection;
  10. use EasyCorp\Bundle\EasyAdminBundle\Collection\FilterCollection;
  11. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  12. use EasyCorp\Bundle\EasyAdminBundle\Config\Actions;
  13. use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
  14. use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
  15. use EasyCorp\Bundle\EasyAdminBundle\Config\Filters;
  16. use EasyCorp\Bundle\EasyAdminBundle\Config\KeyValueStore;
  17. use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
  18. use EasyCorp\Bundle\EasyAdminBundle\Context\AdminContext;
  19. use EasyCorp\Bundle\EasyAdminBundle\Contracts\Controller\CrudControllerInterface;
  20. use EasyCorp\Bundle\EasyAdminBundle\Dto\AssetsDto;
  21. use EasyCorp\Bundle\EasyAdminBundle\Dto\BatchActionDto;
  22. use EasyCorp\Bundle\EasyAdminBundle\Dto\EntityDto;
  23. use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
  24. use EasyCorp\Bundle\EasyAdminBundle\Dto\SearchDto;
  25. use EasyCorp\Bundle\EasyAdminBundle\Event\AfterCrudActionEvent;
  26. use EasyCorp\Bundle\EasyAdminBundle\Event\AfterEntityDeletedEvent;
  27. use EasyCorp\Bundle\EasyAdminBundle\Event\AfterEntityPersistedEvent;
  28. use EasyCorp\Bundle\EasyAdminBundle\Event\AfterEntityUpdatedEvent;
  29. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeCrudActionEvent;
  30. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityDeletedEvent;
  31. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityPersistedEvent;
  32. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityUpdatedEvent;
  33. use EasyCorp\Bundle\EasyAdminBundle\Exception\EntityRemoveException;
  34. use EasyCorp\Bundle\EasyAdminBundle\Exception\ForbiddenActionException;
  35. use EasyCorp\Bundle\EasyAdminBundle\Exception\InsufficientEntityPermissionException;
  36. use EasyCorp\Bundle\EasyAdminBundle\Factory\ActionFactory;
  37. use EasyCorp\Bundle\EasyAdminBundle\Factory\ControllerFactory;
  38. use EasyCorp\Bundle\EasyAdminBundle\Factory\EntityFactory;
  39. use EasyCorp\Bundle\EasyAdminBundle\Factory\FieldFactory;
  40. use EasyCorp\Bundle\EasyAdminBundle\Factory\FilterFactory;
  41. use EasyCorp\Bundle\EasyAdminBundle\Factory\FormFactory;
  42. use EasyCorp\Bundle\EasyAdminBundle\Factory\PaginatorFactory;
  43. use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
  44. use EasyCorp\Bundle\EasyAdminBundle\Field\BooleanField;
  45. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\FileUploadType;
  46. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\FiltersFormType;
  47. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\Model\FileUploadState;
  48. use EasyCorp\Bundle\EasyAdminBundle\Orm\EntityRepository;
  49. use EasyCorp\Bundle\EasyAdminBundle\Orm\EntityUpdater;
  50. use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
  51. use EasyCorp\Bundle\EasyAdminBundle\Provider\FieldProvider;
  52. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  53. use EasyCorp\Bundle\EasyAdminBundle\Security\Permission;
  54. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  55. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  56. use Symfony\Component\Form\FormBuilderInterface;
  57. use Symfony\Component\Form\FormInterface;
  58. use Symfony\Component\HttpFoundation\JsonResponse;
  59. use Symfony\Component\HttpFoundation\RedirectResponse;
  60. use Symfony\Component\HttpFoundation\Response;
  61. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  62. use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
  63. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  64. use Symfony\Component\Security\Core\Exception\InvalidCsrfTokenException;
  65. use function Symfony\Component\String\u;
  67. /**
  68.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  69.  *
  70.  * @template TEntity of object
  71.  *
  72.  * @implements  CrudControllerInterface<TEntity>
  73.  */
  74. abstract class AbstractCrudController extends AbstractController implements CrudControllerInterface
  75. {
  76.     abstract public static function getEntityFqcn(): string;
  78.     public function configureCrud(Crud $crud): Crud
  79.     {
  80.         return $crud;
  81.     }
  83.     public function configureAssets(Assets $assets): Assets
  84.     {
  85.         return $assets;
  86.     }
  88.     public function configureActions(Actions $actions): Actions
  89.     {
  90.         return $actions;
  91.     }
  93.     public function configureFilters(Filters $filters): Filters
  94.     {
  95.         return $filters;
  96.     }
  98.     public function configureFields(string $pageName): iterable
  99.     {
  100.         return $this->container->get(FieldProvider::class)->getDefaultFields($pageName);
  101.     }
  103.     public static function getSubscribedServices(): array
  104.     {
  105.         return array_merge(parent::getSubscribedServices(), [
  106.             'doctrine' => '?'.ManagerRegistry::class,
  107.             'event_dispatcher' => '?'.EventDispatcherInterface::class,
  108.             ActionFactory::class => '?'.ActionFactory::class,
  109.             AdminContextProvider::class => '?'.AdminContextProvider::class,
  110.             AdminUrlGenerator::class => '?'.AdminUrlGenerator::class,
  111.             ControllerFactory::class => '?'.ControllerFactory::class,
  112.             EntityFactory::class => '?'.EntityFactory::class,
  113.             EntityRepository::class => '?'.EntityRepository::class,
  114.             EntityUpdater::class => '?'.EntityUpdater::class,
  115.             FieldProvider::class => '?'.FieldProvider::class,
  116.             FilterFactory::class => '?'.FilterFactory::class,
  117.             FormFactory::class => '?'.FormFactory::class,
  118.             PaginatorFactory::class => '?'.PaginatorFactory::class,
  119.             FieldFactory::class => '?'.FieldFactory::class,
  120.         ]);
  121.     }
  123.     public function index(AdminContext $context): KeyValueStore|Response
  124.     {
  125.         $event = new BeforeCrudActionEvent($context);
  126.         $this->container->get('event_dispatcher')->dispatch($event);
  127.         if ($event->isPropagationStopped()) {
  128.             return $event->getResponse();
  129.         }
  131.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::INDEX, 'entity' => null, 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  132.             throw new ForbiddenActionException($context);
  133.         }
  135.         $fields = new FieldCollection($this->configureFields(Crud::PAGE_INDEX));
  136.         $filters = $this->container->get(FilterFactory::class)->create($context->getCrud()->getFiltersConfig(), $fields, $context->getEntity());
  137.         $queryBuilder = $this->createIndexQueryBuilder($context->getSearch(), $context->getEntity(), $fields, $filters);
  138.         $paginator = $this->container->get(PaginatorFactory::class)->create($queryBuilder);
  140.         // this can happen after deleting some items and trying to return
  141.         // to a 'index' page that no longer exists. Redirect to the last page instead
  142.         if ($paginator->isOutOfRange()) {
  143.             return $this->redirect($this->container->get(AdminUrlGenerator::class)
  144.                 ->set(EA::PAGE, $paginator->getLastPage())
  145.                 ->generateUrl());
  146.         }
  148.         $entities = $this->container->get(EntityFactory::class)->createCollection($context->getEntity(), $paginator->getResults());
  149.         $this->container->get(FieldFactory::class)->processFieldsForAll($entities, $fields, Crud::PAGE_INDEX);
  150.         $processedFields = $entities->first()?->getFields() ?? new FieldCollection([]);
  151.         $context->getCrud()->setFieldAssets($this->getFieldAssets($processedFields));
  152.         $actions = $this->container->get(ActionFactory::class)->processGlobalActionsAndEntityActionsForAll($entities, $context->getCrud()->getActionsConfig());
  154.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  155.             'pageName' => Crud::PAGE_INDEX,
  156.             'templateName' => 'crud/index',
  157.             'entities' => $entities,
  158.             'paginator' => $paginator,
  159.             'global_actions' => $actions->getGlobalActions(),
  160.             'batch_actions' => $actions->getBatchActions(),
  161.             'filters' => $filters,
  162.         ]));
  164.         $event = new AfterCrudActionEvent($context, $responseParameters);
  165.         $this->container->get('event_dispatcher')->dispatch($event);
  166.         if ($event->isPropagationStopped()) {
  167.             return $event->getResponse();
  168.         }
  170.         return $responseParameters;
  171.     }
  173.     public function detail(AdminContext $context): KeyValueStore|Response
  174.     {
  175.         $event = new BeforeCrudActionEvent($context);
  176.         $this->container->get('event_dispatcher')->dispatch($event);
  177.         if ($event->isPropagationStopped()) {
  178.             return $event->getResponse();
  179.         }
  181.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DETAIL, 'entity' => $context->getEntity(), 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  182.             throw new ForbiddenActionException($context);
  183.         }
  185.         if (!$context->getEntity()->isAccessible()) {
  186.             throw new InsufficientEntityPermissionException($context);
  187.         }
  189.         $this->container->get(FieldFactory::class)->processFields($context->getEntity(), new FieldCollection($this->configureFields(Crud::PAGE_DETAIL)), Crud::PAGE_DETAIL);
  190.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  191.         $this->container->get(ActionFactory::class)->processEntityActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  193.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  194.             'pageName' => Crud::PAGE_DETAIL,
  195.             'templateName' => 'crud/detail',
  196.             'entity' => $context->getEntity(),
  197.         ]));
  199.         $event = new AfterCrudActionEvent($context, $responseParameters);
  200.         $this->container->get('event_dispatcher')->dispatch($event);
  201.         if ($event->isPropagationStopped()) {
  202.             return $event->getResponse();
  203.         }
  205.         return $responseParameters;
  206.     }
  208.     public function edit(AdminContext $context): KeyValueStore|Response
  209.     {
  210.         $event = new BeforeCrudActionEvent($context);
  211.         $this->container->get('event_dispatcher')->dispatch($event);
  212.         if ($event->isPropagationStopped()) {
  213.             return $event->getResponse();
  214.         }
  216.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::EDIT, 'entity' => $context->getEntity(), 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  217.             throw new ForbiddenActionException($context);
  218.         }
  220.         if (!$context->getEntity()->isAccessible()) {
  221.             throw new InsufficientEntityPermissionException($context);
  222.         }
  224.         $this->container->get(FieldFactory::class)->processFields($context->getEntity(), new FieldCollection($this->configureFields(Crud::PAGE_EDIT)), Crud::PAGE_EDIT);
  225.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  226.         $this->container->get(ActionFactory::class)->processEntityActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  227.         /** @var TEntity $entityInstance */
  228.         $entityInstance = $context->getEntity()->getInstance();
  230.         if ($context->getRequest()->isXmlHttpRequest()) {
  231.             if ('PATCH' !== $context->getRequest()->getMethod()) {
  232.                 throw new MethodNotAllowedHttpException(['PATCH']);
  233.             }
  235.             if (!$this->isCsrfTokenValid(BooleanField::CSRF_TOKEN_NAME, $context->getRequest()->query->get('csrfToken'))) {
  236.                 throw new InvalidCsrfTokenException();
  237.             }
  239.             $fieldName = $context->getRequest()->query->get('fieldName');
  240.             $newValue = 'true' === mb_strtolower($context->getRequest()->query->get('newValue'));
  242.             try {
  243.                 $event = $this->ajaxEdit($context->getEntity(), $fieldName, $newValue);
  244.             } catch (\Exception $e) {
  245.                 throw new BadRequestHttpException($e->getMessage());
  246.             }
  248.             if ($event->isPropagationStopped()) {
  249.                 return $event->getResponse();
  250.             }
  252.             return new Response($newValue ? '1' : '0');
  253.         }
  255.         $editForm = $this->createEditForm($context->getEntity(), $context->getCrud()->getEditFormOptions(), $context);
  256.         $editForm->handleRequest($context->getRequest());
  257.         if ($editForm->isSubmitted() && $editForm->isValid()) {
  258.             $this->processUploadedFiles($editForm);
  260.             $event = new BeforeEntityUpdatedEvent($entityInstance);
  261.             $this->container->get('event_dispatcher')->dispatch($event);
  262.             $entityInstance = $event->getEntityInstance();
  264.             $this->updateEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  266.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityUpdatedEvent($entityInstance));
  268.             return $this->getRedirectResponseAfterSave($context, Action::EDIT);
  269.         }
  271.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  272.             'pageName' => Crud::PAGE_EDIT,
  273.             'templateName' => 'crud/edit',
  274.             'edit_form' => $editForm,
  275.             'entity' => $context->getEntity(),
  276.         ]));
  278.         $event = new AfterCrudActionEvent($context, $responseParameters);
  279.         $this->container->get('event_dispatcher')->dispatch($event);
  280.         if ($event->isPropagationStopped()) {
  281.             return $event->getResponse();
  282.         }
  284.         return $responseParameters;
  285.     }
  287.     public function new(AdminContext $context): KeyValueStore|Response
  288.     {
  289.         $event = new BeforeCrudActionEvent($context);
  290.         $this->container->get('event_dispatcher')->dispatch($event);
  291.         if ($event->isPropagationStopped()) {
  292.             return $event->getResponse();
  293.         }
  295.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::NEW, 'entity' => null, 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  296.             throw new ForbiddenActionException($context);
  297.         }
  299.         if (!$context->getEntity()->isAccessible()) {
  300.             throw new InsufficientEntityPermissionException($context);
  301.         }
  303.         /** @var class-string<TEntity> $entityFqcn */
  304.         $entityFqcn = $context->getEntity()->getFqcn();
  305.         $context->getEntity()->setInstance($this->createEntity($entityFqcn));
  306.         $this->container->get(FieldFactory::class)->processFields($context->getEntity(), new FieldCollection($this->configureFields(Crud::PAGE_NEW)), Crud::PAGE_NEW);
  307.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  308.         $this->container->get(ActionFactory::class)->processEntityActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  310.         $newForm = $this->createNewForm($context->getEntity(), $context->getCrud()->getNewFormOptions(), $context);
  311.         $newForm->handleRequest($context->getRequest());
  313.         /** @var TEntity $entityInstance */
  314.         $entityInstance = $newForm->getData();
  315.         $context->getEntity()->setInstance($entityInstance);
  317.         if ($newForm->isSubmitted() && $newForm->isValid()) {
  318.             $this->processUploadedFiles($newForm);
  320.             $event = new BeforeEntityPersistedEvent($entityInstance);
  321.             $this->container->get('event_dispatcher')->dispatch($event);
  322.             $entityInstance = $event->getEntityInstance();
  324.             $this->persistEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  326.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityPersistedEvent($entityInstance));
  327.             $context->getEntity()->setInstance($entityInstance);
  329.             return $this->getRedirectResponseAfterSave($context, Action::NEW);
  330.         }
  332.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  333.             'pageName' => Crud::PAGE_NEW,
  334.             'templateName' => 'crud/new',
  335.             'entity' => $context->getEntity(),
  336.             'new_form' => $newForm,
  337.         ]));
  339.         $event = new AfterCrudActionEvent($context, $responseParameters);
  340.         $this->container->get('event_dispatcher')->dispatch($event);
  341.         if ($event->isPropagationStopped()) {
  342.             return $event->getResponse();
  343.         }
  345.         return $responseParameters;
  346.     }
  348.     public function delete(AdminContext $context): KeyValueStore|Response
  349.     {
  350.         $event = new BeforeCrudActionEvent($context);
  351.         $this->container->get('event_dispatcher')->dispatch($event);
  352.         if ($event->isPropagationStopped()) {
  353.             return $event->getResponse();
  354.         }
  356.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DELETE, 'entity' => $context->getEntity(), 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  357.             throw new ForbiddenActionException($context);
  358.         }
  360.         if (!$context->getEntity()->isAccessible()) {
  361.             throw new InsufficientEntityPermissionException($context);
  362.         }
  364.         $csrfToken = $context->getRequest()->request->has('token')
  365.             ? (string) $context->getRequest()->request->get('token')
  366.             : null;
  367.         if ($this->container->has('security.csrf.token_manager') && !$this->isCsrfTokenValid('ea-delete', $csrfToken)) {
  368.             return $this->redirectToRoute($context->getDashboardRouteName());
  369.         }
  371.         /** @var TEntity $entityInstance */
  372.         $entityInstance = $context->getEntity()->getInstance();
  374.         $event = new BeforeEntityDeletedEvent($entityInstance);
  375.         $this->container->get('event_dispatcher')->dispatch($event);
  376.         if ($event->isPropagationStopped()) {
  377.             return $event->getResponse();
  378.         }
  379.         $entityInstance = $event->getEntityInstance();
  381.         try {
  382.             $this->deleteEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  383.         } catch (ForeignKeyConstraintViolationException $e) {
  384.             throw new EntityRemoveException(['entity_name' => $context->getEntity()->getName(), 'message' => $e->getMessage()], $e);
  385.         }
  387.         $this->container->get('event_dispatcher')->dispatch(new AfterEntityDeletedEvent($entityInstance));
  389.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  390.             'entity' => $context->getEntity(),
  391.         ]));
  393.         $event = new AfterCrudActionEvent($context, $responseParameters);
  394.         $this->container->get('event_dispatcher')->dispatch($event);
  395.         if ($event->isPropagationStopped()) {
  396.             return $event->getResponse();
  397.         }
  399.         return $this->redirect($this->container->get(AdminUrlGenerator::class)->setController($context->getCrud()->getControllerFqcn())->setAction(Action::INDEX)->unset(EA::ENTITY_ID)->generateUrl());
  400.     }
  402.     /**
  403.      * @param BatchActionDto<TEntity> $batchActionDto
  404.      */
  405.     public function batchDelete(AdminContext $context, BatchActionDto $batchActionDto): Response
  406.     {
  407.         $event = new BeforeCrudActionEvent($context);
  408.         $this->container->get('event_dispatcher')->dispatch($event);
  409.         if ($event->isPropagationStopped()) {
  410.             return $event->getResponse();
  411.         }
  413.         if (!$this->isCsrfTokenValid('ea-batch-action-'.Action::BATCH_DELETE, $batchActionDto->getCsrfToken())) {
  414.             return $this->redirectToRoute($context->getDashboardRouteName());
  415.         }
  417.         /** @var EntityManagerInterface $entityManager */
  418.         $entityManager = $this->container->get('doctrine')->getManagerForClass($batchActionDto->getEntityFqcn());
  419.         $repository = $entityManager->getRepository($batchActionDto->getEntityFqcn());
  420.         foreach ($batchActionDto->getEntityIds() as $entityId) {
  421.             $entityInstance = $repository->find($entityId);
  422.             if (null === $entityInstance) {
  423.                 continue;
  424.             }
  426.             $entityDto = $context->getEntity()->newWithInstance($entityInstance);
  427.             if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DELETE, 'entity' => $entityDto, 'entityFqcn' => $context->getEntity()->getFqcn()])) {
  428.                 throw new ForbiddenActionException($context);
  429.             }
  431.             if (!$entityDto->isAccessible()) {
  432.                 throw new InsufficientEntityPermissionException($context);
  433.             }
  435.             $event = new BeforeEntityDeletedEvent($entityInstance);
  436.             $this->container->get('event_dispatcher')->dispatch($event);
  437.             if ($event->isPropagationStopped()) {
  438.                 return $event->getResponse();
  439.             }
  440.             $entityInstance = $event->getEntityInstance();
  442.             try {
  443.                 $this->deleteEntity($entityManager, $entityInstance);
  444.             } catch (ForeignKeyConstraintViolationException $e) {
  445.                 throw new EntityRemoveException(['entity_name' => (string) $entityDto, 'message' => $e->getMessage()], $e);
  446.             }
  448.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityDeletedEvent($entityInstance));
  449.         }
  451.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  452.             'entity' => $context->getEntity(),
  453.             'batchActionDto' => $batchActionDto,
  454.         ]));
  456.         $event = new AfterCrudActionEvent($context, $responseParameters);
  457.         $this->container->get('event_dispatcher')->dispatch($event);
  458.         if ($event->isPropagationStopped()) {
  459.             return $event->getResponse();
  460.         }
  462.         $redirectUrl = $this->container->get(AdminUrlGenerator::class)
  463.             // reset the page number to avoid confusing elements after the page reload
  464.             // (we're deleting items, so the original listing pages will change)
  465.             ->unset(EA::PAGE)
  466.             ->setController($context->getCrud()->getControllerFqcn())
  467.             ->setAction(Action::INDEX)
  468.             ->generateUrl();
  470.         return $this->redirect($redirectUrl);
  471.     }
  473.     public function autocomplete(AdminContext $context): JsonResponse
  474.     {
  475.         $queryBuilder = $this->createIndexQueryBuilder($context->getSearch(), $context->getEntity(), new FieldCollection([]), new FilterCollection());
  477.         $autocompleteContext = $context->getRequest()->query->all(AssociationField::PARAM_AUTOCOMPLETE_CONTEXT);
  479.         if (!isset($autocompleteContext['originatingPage'], $autocompleteContext['propertyName'])) {
  480.             throw new \RuntimeException('Invalid autocomplete context: missing required parameters "originatingPage" or "propertyName".');
  481.         }
  483.         $crudControllerFqcn = $autocompleteContext[EA::CRUD_CONTROLLER_FQCN] ?? $context->getRequest()->attributes->get(EA::CRUD_CONTROLLER_FQCN) ?? $context->getRequest()->query->get(EA::CRUD_CONTROLLER_FQCN);
  484.         /** @var CrudControllerInterface $controller */
  485.         $controller = $this->container->get(ControllerFactory::class)->getCrudControllerInstance($crudControllerFqcn, Action::INDEX, $context->getRequest());
  486.         $originatingPage = $autocompleteContext['originatingPage'];
  487.         $propertyName = $autocompleteContext['propertyName'];
  488.         $fields = new FieldCollection($controller->configureFields($originatingPage));
  490.         // find the first field with matching property that is displayed on the originating page;
  491.         // this ensures we get the correct field when a controller defines more than one field for the
  492.         // same property, each of them displayed only on certain pages (via hideOnIndex(), onlyOnForms(), etc.)
  493.         /** @var FieldDto|null $field */
  494.         $field = null;
  495.         foreach ($fields as $fieldDto) {
  496.             if ($propertyName === $fieldDto->getProperty() && $fieldDto->isDisplayedOn($originatingPage)) {
  497.                 $field = $fieldDto;
  498.                 break;
  499.             }
  500.         }
  502.         /** @var \Closure|null $queryBuilderCallable */
  503.         $queryBuilderCallable = $field?->getCustomOption(AssociationField::OPTION_QUERY_BUILDER_CALLABLE);
  505.         if (null !== $queryBuilderCallable) {
  506.             $queryBuilder = $queryBuilderCallable($queryBuilder) ?? $queryBuilder;
  507.         }
  509.         $callback = $field?->getCustomOption(AssociationField::OPTION_AUTOCOMPLETE_CALLBACK)
  510.             ?? $context->getCrud()?->getAutocompleteCallback();
  512.         $template = $field?->getCustomOption(AssociationField::OPTION_AUTOCOMPLETE_TEMPLATE)
  513.             ?? $context->getCrud()?->getAutocompleteTemplate();
  515.         // at field-level, the option is OPTION_ESCAPE_HTML_CONTENTS, which is "render as HTML" inverted
  516.         $fieldEscapeHtml = $field?->getCustomOption(AssociationField::OPTION_ESCAPE_HTML_CONTENTS);
  517.         $renderAsHtml = (null !== $fieldEscapeHtml && false === $fieldEscapeHtml)
  518.             || (null === $fieldEscapeHtml && $context->getCrud()?->getAutocompleteRenderAsHtml());
  520.         $paginator = $this->container->get(PaginatorFactory::class)->create($queryBuilder);
  522.         return JsonResponse::fromJsonString($paginator->getResultsAsJson($callback, $template, $renderAsHtml));
  523.     }
  525.     public function createIndexQueryBuilder(SearchDto $searchDto, EntityDto $entityDto, FieldCollection $fields, FilterCollection $filters): QueryBuilder
  526.     {
  527.         return $this->container->get(EntityRepository::class)->createQueryBuilder($searchDto, $entityDto, $fields, $filters);
  528.     }
  530.     public function renderFilters(AdminContext $context): KeyValueStore
  531.     {
  532.         $fields = new FieldCollection($this->configureFields(Crud::PAGE_INDEX));
  533.         $this->container->get(FieldFactory::class)->processFields($context->getEntity(), $fields, Crud::PAGE_INDEX);
  534.         $filters = $this->container->get(FilterFactory::class)->create($context->getCrud()->getFiltersConfig(), $context->getEntity()->getFields(), $context->getEntity());
  536.         /** @var FormInterface&FiltersFormType $filtersForm */
  537.         $filtersForm = $this->container->get(FormFactory::class)->createFiltersForm($filters, $context->getRequest());
  538.         $formActionParts = parse_url($filtersForm->getConfig()->getAction());
  539.         $queryString = $formActionParts[EA::QUERY] ?? '';
  540.         parse_str($queryString, $queryStringAsArray);
  541.         unset($queryStringAsArray[EA::FILTERS], $queryStringAsArray[EA::PAGE]);
  543.         $responseParameters = KeyValueStore::new([
  544.             'templateName' => 'crud/filters',
  545.             'filters_form' => $filtersForm,
  546.             'form_action_query_string_as_array' => $queryStringAsArray,
  547.         ]);
  549.         return $this->configureResponseParameters($responseParameters);
  550.     }
  552.     public function createEntity(string $entityFqcn): object
  553.     {
  554.         return new $entityFqcn();
  555.     }
  557.     public function updateEntity(EntityManagerInterface $entityManager, object $entityInstance): void
  558.     {
  559.         $entityManager->persist($entityInstance);
  560.         $entityManager->flush();
  561.     }
  563.     public function persistEntity(EntityManagerInterface $entityManager, object $entityInstance): void
  564.     {
  565.         $entityManager->persist($entityInstance);
  566.         $entityManager->flush();
  567.     }
  569.     public function deleteEntity(EntityManagerInterface $entityManager, object $entityInstance): void
  570.     {
  571.         $entityManager->remove($entityInstance);
  572.         $entityManager->flush();
  573.     }
  575.     public function createEditForm(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormInterface
  576.     {
  577.         return $this->createEditFormBuilder($entityDto, $formOptions, $context)->getForm();
  578.     }
  580.     public function createEditFormBuilder(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormBuilderInterface
  581.     {
  582.         return $this->container->get(FormFactory::class)->createEditFormBuilder($entityDto, $formOptions, $context);
  583.     }
  585.     public function createNewForm(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormInterface
  586.     {
  587.         return $this->createNewFormBuilder($entityDto, $formOptions, $context)->getForm();
  588.     }
  590.     public function createNewFormBuilder(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormBuilderInterface
  591.     {
  592.         return $this->container->get(FormFactory::class)->createNewFormBuilder($entityDto, $formOptions, $context);
  593.     }
  595.     /**
  596.      * Used to add/modify/remove parameters before passing them to the Twig template.
  597.      */
  598.     public function configureResponseParameters(KeyValueStore $responseParameters): KeyValueStore
  599.     {
  600.         return $responseParameters;
  601.     }
  603.     protected function getContext(): ?AdminContext
  604.     {
  605.         return $this->container->get(AdminContextProvider::class)->getContext();
  606.     }
  608.     /**
  609.      * @param EntityDto<TEntity> $entityDto
  610.      */
  611.     protected function ajaxEdit(EntityDto $entityDto, ?string $propertyName, bool $newValue): AfterCrudActionEvent
  612.     {
  613.         $field = $entityDto->getFields()->getByProperty($propertyName);
  614.         if (null === $field || true === $field->getFormTypeOption('disabled')) {
  615.             throw new AccessDeniedException(sprintf('The field "%s" does not exist or it\'s configured as disabled, so it can\'t be modified.', $propertyName));
  616.         }
  618.         $this->container->get(EntityUpdater::class)->updateProperty($entityDto, $propertyName, $newValue);
  620.         /** @var TEntity $entityInstance */
  621.         $entityInstance = $entityDto->getInstance();
  622.         $event = new BeforeEntityUpdatedEvent($entityInstance);
  623.         $this->container->get('event_dispatcher')->dispatch($event);
  624.         $entityInstance = $event->getEntityInstance();
  626.         $this->updateEntity($this->container->get('doctrine')->getManagerForClass($entityDto->getFqcn()), $entityInstance);
  628.         $this->container->get('event_dispatcher')->dispatch(new AfterEntityUpdatedEvent($entityInstance));
  630.         $entityDto->setInstance($entityInstance);
  632.         $parameters = KeyValueStore::new([
  633.             'action' => Action::EDIT,
  634.             'entity' => $entityDto,
  635.         ]);
  637.         $event = new AfterCrudActionEvent($this->getContext(), $parameters);
  638.         $this->container->get('event_dispatcher')->dispatch($event);
  640.         return $event;
  641.     }
  643.     protected function processUploadedFiles(FormInterface $form): void
  644.     {
  645.         /** @var FormInterface $child */
  646.         foreach ($form as $child) {
  647.             $config = $child->getConfig();
  649.             if (!$config->getType()->getInnerType() instanceof FileUploadType) {
  650.                 if ($config->getCompound()) {
  651.                     $this->processUploadedFiles($child);
  652.                 }
  654.                 continue;
  655.             }
  657.             /** @var FileUploadState $state */
  658.             $state = $config->getAttribute('state');
  660.             if (!$state->isModified()) {
  661.                 continue;
  662.             }
  664.             $uploadDelete = $config->getOption('upload_delete');
  666.             if ($state->hasCurrentFiles() && ($state->isDelete() || (!$state->isAddAllowed() && $state->hasUploadedFiles()))) {
  667.                 foreach ($state->getCurrentFiles() as $file) {
  668.                     $uploadDelete($file);
  669.                 }
  670.                 $state->setCurrentFiles([]);
  671.             }
  673.             $filePaths = (array) $child->getData();
  674.             $uploadDir = $config->getOption('upload_dir');
  675.             $uploadNew = $config->getOption('upload_new');
  677.             foreach ($state->getUploadedFiles() as $index => $file) {
  678.                 $fileName = u($filePaths[$index])->replace($uploadDir, '')->toString();
  679.                 $uploadNew($file, $uploadDir, $fileName);
  680.             }
  681.         }
  682.     }
  684.     protected function getRedirectResponseAfterSave(AdminContext $context, string $action): RedirectResponse
  685.     {
  686.         $submitButtonName = $context->getRequest()->request->all()['ea']['newForm']['btn'] ?? null;
  688.         $url = match ($submitButtonName) {
  689.             Action::SAVE_AND_CONTINUE => $this->container->get(AdminUrlGenerator::class)
  690.                 ->setAction(Action::EDIT)
  691.                 ->setEntityId($context->getEntity()->getPrimaryKeyValue())
  692.                 ->generateUrl(),
  693.             Action::SAVE_AND_RETURN => $this->container->get(AdminUrlGenerator::class)->setAction(Action::INDEX)->generateUrl(),
  694.             Action::SAVE_AND_ADD_ANOTHER => $this->container->get(AdminUrlGenerator::class)->setAction(Action::NEW)->generateUrl(),
  695.             default => $this->generateUrl($context->getDashboardRouteName()),
  696.         };
  698.         return $this->redirect($url);
  699.     }
  701.     protected function getFieldAssets(FieldCollection $fieldDtos): AssetsDto
  702.     {
  703.         $fieldAssetsDto = new AssetsDto();
  704.         $currentPageName = $this->getContext()?->getCrud()?->getCurrentPage();
  705.         foreach ($fieldDtos as $fieldDto) {
  706.             $fieldAssetsDto = $fieldAssetsDto->mergeWith($fieldDto->getAssets()->loadedOn($currentPageName));
  707.         }
  709.         return $fieldAssetsDto;
  710.     }
  711. }