src/Controller/Overriding/FlexyAbstractCrudController.php line 165

  1. <?php
  3. namespace App\Controller\Overriding;
  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\FilterFactory;
  40. use EasyCorp\Bundle\EasyAdminBundle\Factory\FormFactory;
  41. use EasyCorp\Bundle\EasyAdminBundle\Factory\PaginatorFactory;
  42. use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
  43. use EasyCorp\Bundle\EasyAdminBundle\Field\BooleanField;
  44. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\FileUploadType;
  45. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\FiltersFormType;
  46. use EasyCorp\Bundle\EasyAdminBundle\Form\Type\Model\FileUploadState;
  47. use EasyCorp\Bundle\EasyAdminBundle\Orm\EntityRepository;
  48. use EasyCorp\Bundle\EasyAdminBundle\Orm\EntityUpdater;
  49. use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
  50. use EasyCorp\Bundle\EasyAdminBundle\Provider\FieldProvider;
  51. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  52. use EasyCorp\Bundle\EasyAdminBundle\Security\Permission;
  53. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  54. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  55. use Symfony\Component\Form\FormBuilderInterface;
  56. use Symfony\Component\Form\FormInterface;
  57. use Symfony\Component\HttpFoundation\JsonResponse;
  58. use Symfony\Component\HttpFoundation\RedirectResponse;
  59. use Symfony\Component\HttpFoundation\Response;
  60. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  61. use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
  62. use Symfony\Component\Security\Core\Exception\InvalidCsrfTokenException;
  63. use function Symfony\Component\String\u;
  65. /**
  66.  * @author Samir Mengadi 
  67.  */
  68. abstract class FlexyAbstractCrudController extends AbstractController implements CrudControllerInterface
  69. {
  70.     abstract public static function getEntityFqcn(): string;
  72.     public function configureCrud(Crud $crud): Crud
  73.     {
  74.         return $crud;
  75.     }
  77.     public function configureAssets(Assets $assets): Assets
  78.     {
  79.         return $assets;
  80.     }
  82.     public function configureActions(Actions $actions): Actions
  83.     {
  84.         return $actions;
  85.     }
  87.     public function configureFilters(Filters $filters): Filters
  88.     {
  89.         return $filters;
  90.     }
  92.     public function configureFields(string $pageName): iterable
  93.     {
  94.         return $this->container->get(FieldProvider::class)->getDefaultFields($pageName);
  95.     }
  97.     public static function getSubscribedServices(): array
  98.     {
  99.         return array_merge(parent::getSubscribedServices(), [
  100.             'doctrine' => '?'.ManagerRegistry::class,
  101.             'event_dispatcher' => '?'.EventDispatcherInterface::class,
  102.             ActionFactory::class => '?'.ActionFactory::class,
  103.             AdminContextProvider::class => '?'.AdminContextProvider::class,
  104.             AdminUrlGenerator::class => '?'.AdminUrlGenerator::class,
  105.             ControllerFactory::class => '?'.ControllerFactory::class,
  106.             EntityFactory::class => '?'.EntityFactory::class,
  107.             EntityRepository::class => '?'.EntityRepository::class,
  108.             EntityUpdater::class => '?'.EntityUpdater::class,
  109.             FieldProvider::class => '?'.FieldProvider::class,
  110.             FilterFactory::class => '?'.FilterFactory::class,
  111.             FormFactory::class => '?'.FormFactory::class,
  112.             PaginatorFactory::class => '?'.PaginatorFactory::class,
  113.         ]);
  114.     }
  116.     public function index(AdminContext $context)
  117.     {
  118.         $event = new BeforeCrudActionEvent($context);
  119.         $this->container->get('event_dispatcher')->dispatch($event);
  120.         if ($event->isPropagationStopped()) {
  121.             return $event->getResponse();
  122.         }
  124.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::INDEX, 'entity' => null])) {
  125.             throw new ForbiddenActionException($context);
  126.         }
  128.         $fields = FieldCollection::new($this->configureFields(Crud::PAGE_INDEX));
  129.         $context->getCrud()->setFieldAssets($this->getFieldAssets($fields));
  130.         $filters = $this->container->get(FilterFactory::class)->create($context->getCrud()->getFiltersConfig(), $fields, $context->getEntity());
  131.         $queryBuilder = $this->createIndexQueryBuilder($context->getSearch(), $context->getEntity(), $fields, $filters);
  132.         $paginator = $this->container->get(PaginatorFactory::class)->create($queryBuilder);
  134.         // this can happen after deleting some items and trying to return
  135.         // to a 'index' page that no longer exists. Redirect to the last page instead
  136.         if ($paginator->isOutOfRange()) {
  137.             return $this->redirect($this->container->get(AdminUrlGenerator::class)
  138.                 ->set(EA::PAGE, $paginator->getLastPage())
  139.                 ->generateUrl());
  140.         }
  142.         $entities = $this->container->get(EntityFactory::class)->createCollection($context->getEntity(), $paginator->getResults());
  143.         $this->container->get(EntityFactory::class)->processFieldsForAll($entities, $fields);
  144.         $actions = $this->container->get(EntityFactory::class)->processActionsForAll($entities, $context->getCrud()->getActionsConfig());
  146.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  147.             'pageName' => Crud::PAGE_INDEX,
  148.             'templateName' => 'crud/index',
  149.             'entities' => $entities,
  150.             'paginator' => $paginator,
  151.             'global_actions' => $actions->getGlobalActions(),
  152.             'batch_actions' => $actions->getBatchActions(),
  153.             'filters' => $filters,
  154.         ]));
  156.         $event = new AfterCrudActionEvent($context, $responseParameters);
  157.         $this->container->get('event_dispatcher')->dispatch($event);
  158.         if ($event->isPropagationStopped()) {
  159.             return $event->getResponse();
  160.         }
  162.         return $responseParameters;
  163.     }
  165.     public function detail(AdminContext $context)
  166.     {
  167.         $event = new BeforeCrudActionEvent($context);
  168.         $this->container->get('event_dispatcher')->dispatch($event);
  169.         if ($event->isPropagationStopped()) {
  170.             return $event->getResponse();
  171.         }
  173.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DETAIL, 'entity' => $context->getEntity()])) {
  174.             throw new ForbiddenActionException($context);
  175.         }
  177.         if (!$context->getEntity()->isAccessible()) {
  178.             throw new InsufficientEntityPermissionException($context);
  179.         }
  181.         $this->container->get(EntityFactory::class)->processFields($context->getEntity(), FieldCollection::new($this->configureFields(Crud::PAGE_DETAIL)));
  182.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  183.         $this->container->get(EntityFactory::class)->processActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  185.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  186.             'pageName' => Crud::PAGE_DETAIL,
  187.             'templateName' => 'crud/detail',
  188.             'entity' => $context->getEntity(),
  189.         ]));
  191.         $event = new AfterCrudActionEvent($context, $responseParameters);
  192.         $this->container->get('event_dispatcher')->dispatch($event);
  193.         if ($event->isPropagationStopped()) {
  194.             return $event->getResponse();
  195.         }
  197.         return $responseParameters;
  198.     }
  200.     public function edit(AdminContext $context)
  201.     {
  203.         $dataTurbo = true;
  204.         $event = new BeforeCrudActionEvent($context);
  205.         $this->container->get('event_dispatcher')->dispatch($event);
  206.         if ($event->isPropagationStopped()) {
  207.             return $event->getResponse();
  208.         }
  210.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::EDIT, 'entity' => $context->getEntity()])) {
  211.             throw new ForbiddenActionException($context);
  212.         }
  214.         if (!$context->getEntity()->isAccessible()) {
  215.             throw new InsufficientEntityPermissionException($context);
  216.         }
  218.         $this->container->get(EntityFactory::class)->processFields($context->getEntity(), FieldCollection::new($this->configureFields(Crud::PAGE_EDIT)));
  219.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  220.         $this->container->get(EntityFactory::class)->processActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  221.         $entityInstance = $context->getEntity()->getInstance();
  223.         if ($context->getRequest()->isXmlHttpRequest()) {
  224.             if ('PATCH' !== $context->getRequest()->getMethod()) {
  225.                 throw new MethodNotAllowedHttpException(['PATCH']);
  226.             }
  228.             if (!$this->isCsrfTokenValid(BooleanField::CSRF_TOKEN_NAME, $context->getRequest()->query->get('csrfToken'))) {
  229.                 if (class_exists(InvalidCsrfTokenException::class)) {
  230.                     throw new InvalidCsrfTokenException();
  231.                 } else {
  232.                     return new Response('Invalid CSRF token.', 400);
  233.                 }
  234.             }
  236.             $fieldName = $context->getRequest()->query->get('fieldName');
  237.             $newValue = 'true' === mb_strtolower($context->getRequest()->query->get('newValue'));
  239.             try {
  240.                 $event = $this->ajaxEdit($context->getEntity(), $fieldName, $newValue);
  241.             } catch (\Exception) {
  242.                 throw new BadRequestHttpException();
  243.             }
  245.             if ($event->isPropagationStopped()) {
  246.                 return $event->getResponse();
  247.             }
  249.             return new Response($newValue ? '1' : '0');
  250.         }
  252.         $editForm = $this->createEditForm($context->getEntity(), $context->getCrud()->getEditFormOptions(), $context);
  253.         $editForm->handleRequest($context->getRequest());
  255.         
  257.         
  259.             
  260.         if ($editForm->isSubmitted() && $editForm->isValid()) {
  261.             $this->processUploadedFiles($editForm);
  263.             $event = new BeforeEntityUpdatedEvent($entityInstance);
  264.             $this->container->get('event_dispatcher')->dispatch($event);
  265.             $entityInstance = $event->getEntityInstance();
  267.             $this->updateEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  268.             
  269.             // Added BySamir
  270.             $this->addFlash("success","Successfully updated");
  271.             
  272.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityUpdatedEvent($entityInstance));
  274.             return $this->getRedirectResponseAfterSave($context, Action::EDIT);
  275.         }
  277.         // Added BySamir
  278.         if ($editForm->isSubmitted() && !$editForm->isValid()) {
  279.             
  280.             foreach($editForm->getErrors() as $singleError){
  281.                 $this->addFlash("danger",$singleError->getMessage());
  282.             }
  283.             foreach($editForm->all() as $child){
  284.                 foreach($child->getErrors() as $singleError){
  285.                     $this->addFlash("danger",$singleError->getMessage());
  286.                 }
  287.             }
  289.             $url = $this->container->get(AdminUrlGenerator::class)
  290.                 ->setAction(Action::EDIT)
  291.                 ->setEntityId($context->getEntity()->getPrimaryKeyValue())
  292.                 ->generateUrl();
  294.             return $this->redirect($url);
  295.             
  296.         }
  298.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  299.             'pageName' => Crud::PAGE_EDIT,
  300.             'templateName' => 'crud/edit',
  301.             'edit_form' => $editForm,
  302.             'entity' => $context->getEntity(),
  303.         ]));
  305.         
  306.         
  308.         $event = new AfterCrudActionEvent($context, $responseParameters);
  309.         $this->container->get('event_dispatcher')->dispatch($event);
  310.         if ($event->isPropagationStopped()) {
  311.             return $event->getResponse();
  312.         }
  314.         return $responseParameters;
  315.     }
  317.     public function new(AdminContext $context)
  318.     {
  319.         $event = new BeforeCrudActionEvent($context);
  320.         $this->container->get('event_dispatcher')->dispatch($event);
  321.         if ($event->isPropagationStopped()) {
  322.             return $event->getResponse();
  323.         }
  325.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::NEW, 'entity' => null])) {
  326.             throw new ForbiddenActionException($context);
  327.         }
  329.         if (!$context->getEntity()->isAccessible()) {
  330.             throw new InsufficientEntityPermissionException($context);
  331.         }
  333.         $context->getEntity()->setInstance($this->createEntity($context->getEntity()->getFqcn()));
  334.         $this->container->get(EntityFactory::class)->processFields($context->getEntity(), FieldCollection::new($this->configureFields(Crud::PAGE_NEW)));
  335.         $context->getCrud()->setFieldAssets($this->getFieldAssets($context->getEntity()->getFields()));
  336.         $this->container->get(EntityFactory::class)->processActions($context->getEntity(), $context->getCrud()->getActionsConfig());
  338.         $newForm = $this->createNewForm($context->getEntity(), $context->getCrud()->getNewFormOptions(), $context);
  339.         $newForm->handleRequest($context->getRequest());
  341.         $entityInstance = $newForm->getData();
  342.         $context->getEntity()->setInstance($entityInstance);
  344.         if ($newForm->isSubmitted() && $newForm->isValid()) {
  345.             $this->processUploadedFiles($newForm);
  347.             $event = new BeforeEntityPersistedEvent($entityInstance);
  348.             $this->container->get('event_dispatcher')->dispatch($event);
  349.             $entityInstance = $event->getEntityInstance();
  351.             $this->persistEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  352.             $this->addFlash("success","Successfully created");
  354.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityPersistedEvent($entityInstance));
  355.             $context->getEntity()->setInstance($entityInstance);
  357.             return $this->getRedirectResponseAfterSave($context, Action::NEW);
  358.         }
  359.         if ($newForm->isSubmitted() && !$newForm->isValid()) {
  361.             
  362.         foreach($newForm->getErrors() as $singleError){
  363.             $this->addFlash("danger",$singleError->getMessage());
  364.         }
  365.         foreach($newForm->all() as $child){
  366.             foreach($child->getErrors() as $singleError){
  367.                 $this->addFlash("danger",$singleError->getMessage());
  368.             }
  369.         }
  371.         $url = $this->container->get(AdminUrlGenerator::class)
  372.             ->setAction(Action::NEW)
  373.             ->generateUrl();
  375.         return $this->redirect($url);
  376.     }
  378.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  379.             'pageName' => Crud::PAGE_NEW,
  380.             'templateName' => 'crud/new',
  381.             'entity' => $context->getEntity(),
  382.             'new_form' => $newForm,
  383.         ]));
  385.         $event = new AfterCrudActionEvent($context, $responseParameters);
  386.         $this->container->get('event_dispatcher')->dispatch($event);
  387.         if ($event->isPropagationStopped()) {
  388.             return $event->getResponse();
  389.         }
  391.         return $responseParameters;
  392.     }
  394.     public function delete(AdminContext $context)
  395.     {
  396.         $event = new BeforeCrudActionEvent($context);
  397.         $this->container->get('event_dispatcher')->dispatch($event);
  398.         if ($event->isPropagationStopped()) {
  399.             return $event->getResponse();
  400.         }
  402.         if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DELETE, 'entity' => $context->getEntity()])) {
  403.             throw new ForbiddenActionException($context);
  404.         }
  406.         if (!$context->getEntity()->isAccessible()) {
  407.             throw new InsufficientEntityPermissionException($context);
  408.         }
  410.         $csrfToken = $context->getRequest()->request->get('token');
  411.         if ($this->container->has('security.csrf.token_manager') && !$this->isCsrfTokenValid('ea-delete', $csrfToken)) {
  412.             return $this->redirectToRoute($context->getDashboardRouteName());
  413.         }
  415.         $entityInstance = $context->getEntity()->getInstance();
  417.         $event = new BeforeEntityDeletedEvent($entityInstance);
  418.         $this->container->get('event_dispatcher')->dispatch($event);
  419.         if ($event->isPropagationStopped()) {
  420.             return $event->getResponse();
  421.         }
  422.         $entityInstance = $event->getEntityInstance();
  424.         try {
  425.             $this->deleteEntity($this->container->get('doctrine')->getManagerForClass($context->getEntity()->getFqcn()), $entityInstance);
  426.         } catch (ForeignKeyConstraintViolationException $e) {
  427.             throw new EntityRemoveException(['entity_name' => $context->getEntity()->getName(), 'message' => $e->getMessage()]);
  428.         }
  430.         $this->container->get('event_dispatcher')->dispatch(new AfterEntityDeletedEvent($entityInstance));
  432.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  433.             'entity' => $context->getEntity(),
  434.         ]));
  436.         $event = new AfterCrudActionEvent($context, $responseParameters);
  437.         $this->container->get('event_dispatcher')->dispatch($event);
  438.         if ($event->isPropagationStopped()) {
  439.             return $event->getResponse();
  440.         }
  442.         if (null !== $referrer = $context->getReferrer()) {
  443.             return $this->redirect($referrer);
  444.         }
  446.         return $this->redirect($this->container->get(AdminUrlGenerator::class)->setAction(Action::INDEX)->unset(EA::ENTITY_ID)->generateUrl());
  447.     }
  449.     public function batchDelete(AdminContext $context, BatchActionDto $batchActionDto): Response
  450.     {
  451.         $event = new BeforeCrudActionEvent($context);
  452.         $this->container->get('event_dispatcher')->dispatch($event);
  453.         if ($event->isPropagationStopped()) {
  454.             return $event->getResponse();
  455.         }
  457.         if (!$this->isCsrfTokenValid('ea-batch-action-'.Action::BATCH_DELETE, $batchActionDto->getCsrfToken())) {
  458.             return $this->redirectToRoute($context->getDashboardRouteName());
  459.         }
  461.         $entityManager = $this->container->get('doctrine')->getManagerForClass($batchActionDto->getEntityFqcn());
  462.         $repository = $entityManager->getRepository($batchActionDto->getEntityFqcn());
  463.         foreach ($batchActionDto->getEntityIds() as $entityId) {
  464.             $entityInstance = $repository->find($entityId);
  465.             if (!$entityInstance) {
  466.                 continue;
  467.             }
  469.             $entityDto = $context->getEntity()->newWithInstance($entityInstance);
  470.             if (!$this->isGranted(Permission::EA_EXECUTE_ACTION, ['action' => Action::DELETE, 'entity' => $entityDto])) {
  471.                 throw new ForbiddenActionException($context);
  472.             }
  474.             if (!$entityDto->isAccessible()) {
  475.                 throw new InsufficientEntityPermissionException($context);
  476.             }
  478.             $event = new BeforeEntityDeletedEvent($entityInstance);
  479.             $this->container->get('event_dispatcher')->dispatch($event);
  480.             $entityInstance = $event->getEntityInstance();
  482.             try {
  483.                 $this->deleteEntity($entityManager, $entityInstance);
  484.             } catch (ForeignKeyConstraintViolationException $e) {
  485.                 throw new EntityRemoveException(['entity_name' => $entityDto->toString(), 'message' => $e->getMessage()]);
  486.             }
  488.             $this->container->get('event_dispatcher')->dispatch(new AfterEntityDeletedEvent($entityInstance));
  489.         }
  491.         $responseParameters = $this->configureResponseParameters(KeyValueStore::new([
  492.             'entity' => $context->getEntity(),
  493.             'batchActionDto' => $batchActionDto,
  494.         ]));
  496.         $event = new AfterCrudActionEvent($context, $responseParameters);
  497.         $this->container->get('event_dispatcher')->dispatch($event);
  498.         if ($event->isPropagationStopped()) {
  499.             return $event->getResponse();
  500.         }
  502.         return $this->redirect($batchActionDto->getReferrerUrl());
  503.     }
  505.     public function autocomplete(AdminContext $context): JsonResponse
  506.     {
  507.         $queryBuilder = $this->createIndexQueryBuilder($context->getSearch(), $context->getEntity(), FieldCollection::new([]), FilterCollection::new());
  509.         $autocompleteContext = $context->getRequest()->get(AssociationField::PARAM_AUTOCOMPLETE_CONTEXT);
  511.         /** @var CrudControllerInterface $controller */
  512.         $controller = $this->container->get(ControllerFactory::class)->getCrudControllerInstance($autocompleteContext[EA::CRUD_CONTROLLER_FQCN], Action::INDEX, $context->getRequest());
  513.         /** @var FieldDto $field */
  514.         $field = FieldCollection::new($controller->configureFields($autocompleteContext['originatingPage']))->getByProperty($autocompleteContext['propertyName']);
  515.         /** @var \Closure|null $queryBuilderCallable */
  516.         $queryBuilderCallable = $field->getCustomOption(AssociationField::OPTION_QUERY_BUILDER_CALLABLE);
  518.         if (null !== $queryBuilderCallable) {
  519.             $queryBuilderCallable($queryBuilder);
  520.         }
  522.         $paginator = $this->container->get(PaginatorFactory::class)->create($queryBuilder);
  524.         return JsonResponse::fromJsonString($paginator->getResultsAsJson());
  525.     }
  527.     public function createIndexQueryBuilder(SearchDto $searchDto, EntityDto $entityDto, FieldCollection $fields, FilterCollection $filters): QueryBuilder
  528.     {
  529.         return $this->container->get(EntityRepository::class)->createQueryBuilder($searchDto, $entityDto, $fields, $filters);
  530.     }
  532.     public function renderFilters(AdminContext $context): KeyValueStore
  533.     {
  534.         $fields = FieldCollection::new($this->configureFields(Crud::PAGE_INDEX));
  535.         $this->container->get(EntityFactory::class)->processFields($context->getEntity(), $fields);
  536.         $filters = $this->container->get(FilterFactory::class)->create($context->getCrud()->getFiltersConfig(), $context->getEntity()->getFields(), $context->getEntity());
  538.         /** @var FormInterface&FiltersFormType $filtersForm */
  539.         $filtersForm = $this->container->get(FormFactory::class)->createFiltersForm($filters, $context->getRequest());
  540.         $formActionParts = parse_url($filtersForm->getConfig()->getAction());
  541.         $queryString = $formActionParts[EA::QUERY] ?? '';
  542.         parse_str($queryString, $queryStringAsArray);
  543.         unset($queryStringAsArray[EA::FILTERS], $queryStringAsArray[EA::PAGE]);
  545.         $responseParameters = KeyValueStore::new([
  546.             'templateName' => 'crud/filters',
  547.             'filters_form' => $filtersForm,
  548.             'form_action_query_string_as_array' => $queryStringAsArray,
  549.         ]);
  551.         return $this->configureResponseParameters($responseParameters);
  552.     }
  554.     public function createEntity(string $entityFqcn)
  555.     {
  556.         return new $entityFqcn();
  557.     }
  559.     public function updateEntity(EntityManagerInterface $entityManager, $entityInstance): void
  560.     {
  561.         $entityManager->persist($entityInstance);
  562.         $entityManager->flush();
  563.     }
  565.     public function persistEntity(EntityManagerInterface $entityManager, $entityInstance): void
  566.     {
  567.         $entityManager->persist($entityInstance);
  568.         $entityManager->flush();
  569.     }
  571.     public function deleteEntity(EntityManagerInterface $entityManager, $entityInstance): void
  572.     {
  573.         $entityManager->remove($entityInstance);
  574.         $entityManager->flush();
  575.     }
  577.     public function createEditForm(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormInterface
  578.     {
  579.         return $this->createEditFormBuilder($entityDto, $formOptions, $context)->getForm();
  580.     }
  582.     public function createEditFormBuilder(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormBuilderInterface
  583.     {
  584.         return $this->container->get(FormFactory::class)->createEditFormBuilder($entityDto, $formOptions, $context);
  585.     }
  587.     public function createNewForm(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormInterface
  588.     {
  589.         return $this->createNewFormBuilder($entityDto, $formOptions, $context)->getForm();
  590.     }
  592.     public function createNewFormBuilder(EntityDto $entityDto, KeyValueStore $formOptions, AdminContext $context): FormBuilderInterface
  593.     {
  594.         return $this->container->get(FormFactory::class)->createNewFormBuilder($entityDto, $formOptions, $context);
  595.     }
  597.     /**
  598.      * Used to add/modify/remove parameters before passing them to the Twig template.
  599.      */
  600.     public function configureResponseParameters(KeyValueStore $responseParameters): KeyValueStore
  601.     {
  602.         return $responseParameters;
  603.     }
  605.     protected function getContext(): ?AdminContext
  606.     {
  607.         return $this->container->get(AdminContextProvider::class)->getContext();
  608.     }
  610.     protected function ajaxEdit(EntityDto $entityDto, ?string $propertyName, bool $newValue): AfterCrudActionEvent
  611.     {
  612.         $this->container->get(EntityUpdater::class)->updateProperty($entityDto, $propertyName, $newValue);
  614.         $event = new BeforeEntityUpdatedEvent($entityDto->getInstance());
  615.         $this->container->get('event_dispatcher')->dispatch($event);
  616.         $entityInstance = $event->getEntityInstance();
  618.         $this->updateEntity($this->container->get('doctrine')->getManagerForClass($entityDto->getFqcn()), $entityInstance);
  620.         $this->container->get('event_dispatcher')->dispatch(new AfterEntityUpdatedEvent($entityInstance));
  622.         $entityDto->setInstance($entityInstance);
  624.         $parameters = KeyValueStore::new([
  625.             'action' => Action::EDIT,
  626.             'entity' => $entityDto,
  627.         ]);
  629.         $event = new AfterCrudActionEvent($this->getContext(), $parameters);
  630.         $this->container->get('event_dispatcher')->dispatch($event);
  632.         return $event;
  633.     }
  635.     protected function processUploadedFiles(FormInterface $form): void
  636.     {
  637.         /** @var FormInterface $child */
  638.         foreach ($form as $child) {
  639.             $config = $child->getConfig();
  641.             if (!$config->getType()->getInnerType() instanceof FileUploadType) {
  642.                 if ($config->getCompound()) {
  643.                     $this->processUploadedFiles($child);
  644.                 }
  646.                 continue;
  647.             }
  649.             /** @var FileUploadState $state */
  650.             $state = $config->getAttribute('state');
  652.             if (!$state->isModified()) {
  653.                 continue;
  654.             }
  656.             $uploadDelete = $config->getOption('upload_delete');
  658.             if ($state->hasCurrentFiles() && ($state->isDelete() || (!$state->isAddAllowed() && $state->hasUploadedFiles()))) {
  659.                 foreach ($state->getCurrentFiles() as $file) {
  660.                     $uploadDelete($file);
  661.                 }
  662.                 $state->setCurrentFiles([]);
  663.             }
  665.             $filePaths = (array) $child->getData();
  666.             $uploadDir = $config->getOption('upload_dir');
  667.             $uploadNew = $config->getOption('upload_new');
  669.             foreach ($state->getUploadedFiles() as $index => $file) {
  670.                 $fileName = u($filePaths[$index])->replace($uploadDir, '')->toString();
  671.                 $uploadNew($file, $uploadDir, $fileName);
  672.             }
  673.         }
  674.     }
  676.     protected function getRedirectResponseAfterSave(AdminContext $context, string $action): RedirectResponse
  677.     {
  679.         
  680.         $submitButtonName = $context->getRequest()->request->all()['ea']['newForm']['btn'];
  682.         if (Action::SAVE_AND_CONTINUE === $submitButtonName) {
  683.             $url = $this->container->get(AdminUrlGenerator::class)
  684.                 ->setAction(Action::EDIT)
  685.                 ->setEntityId($context->getEntity()->getPrimaryKeyValue())
  686.                 ->generateUrl();
  688.             return $this->redirect($url);
  689.         }
  691.         if (Action::SAVE_AND_RETURN === $submitButtonName) {
  692.             $url = $context->getReferrer()
  693.                 ?? $this->container->get(AdminUrlGenerator::class)->setAction(Action::INDEX)->generateUrl();
  695.             return $this->redirect($url);
  696.         }
  698.         if (Action::SAVE_AND_ADD_ANOTHER === $submitButtonName) {
  699.             $url = $this->container->get(AdminUrlGenerator::class)->setAction(Action::NEW)->generateUrl();
  701.             return $this->redirect($url);
  702.         }
  704.         return $this->redirectToRoute($context->getDashboardRouteName());
  705.     }
  707.     protected function getFieldAssets(FieldCollection $fieldDtos): AssetsDto
  708.     {
  709.         $fieldAssetsDto = new AssetsDto();
  710.         $currentPageName = $this->getContext()?->getCrud()?->getCurrentPage();
  711.         foreach ($fieldDtos as $fieldDto) {
  712.             $fieldAssetsDto = $fieldAssetsDto->mergeWith($fieldDto->getAssets()->loadedOn($currentPageName));
  713.         }
  715.         return $fieldAssetsDto;
  716.     }
  717. }