Duplication sur section et merchant

Component/EntityComponent.php

 namespace Lc\SovBundle\Component;
 
 use Doctrine\ORM\EntityManagerInterface;
-use Lc\CaracoleBundle\Model\Product\ProductFamilyInterface;
-use Lc\SovBundle\Doctrine\Extension\SluggableInterface;
+use Lc\SovBundle\Event\EntityComponentEvent;
 use Lc\SovBundle\Model\File\FileInterface;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 
 class EntityComponent
 {
     protected EntityManagerInterface $entityManager;
     protected ParameterBagInterface $parameterBag;
+    protected EventDispatcherInterface $eventDispatcher;
 
     public function __construct(
             EntityManagerInterface $entityManager,
-            ParameterBagInterface $parameterBag
+            ParameterBagInterface $parameterBag,
+            EventDispatcherInterface $eventDispatcher
     ) {
         $this->entityManager = $entityManager;
         $this->parameterBag = $parameterBag;
+        $this->eventDispatcher = $eventDispatcher;
     }
 
-    public function duplicateEntity($entity, $flush = true)
+    public function duplicateEntity($entity)
     {
         $newEntity = clone $entity;
+        $classMetadata = $this->entityManager->getClassMetadata(get_class($newEntity));
+
+        foreach ($classMetadata->getAssociationMappings() as $associationMapping){
+            if(in_array(FileInterface::class, class_implements($associationMapping['targetEntity']))){
+                $methodGet = 'get'.ucfirst($associationMapping['fieldName']);
+                $methodSet = 'set'.ucfirst($associationMapping['fieldName']);
+                if(method_exists($newEntity, $methodGet) && method_exists($newEntity, $methodSet)){
+                    if(!is_null($newEntity->$methodGet())){
+                        $newFile = clone $newEntity->$methodGet();
+                        $newEntity->$methodSet($newFile);
+                    }
+                }
+            }
 
-        if ($newEntity instanceof FileInterface) {
-            $newEntity = $this->duplicateImage($newEntity);
         }
 
-        if ($newEntity instanceof ProductFamilyInterface) {
+        //TODO dispatch event duplicate
+      /*  if ($newEntity instanceof ProductFamilyInterface) {
             // @TODO : à adapter
             //$newEntity = $this->productFamilyUtils->processBeforePersistProductFamily($newEntity, false, true);
         }
+*/
+        $this->entityManager->create($newEntity);
 
-        if (method_exists($newEntity, 'getAddress') && is_object($newEntity->getAddress())) {
-            $address = $newEntity->getAddress();
-            $newAddress = $this->duplicateEntity($address);
-            $newEntity->setAddress($newAddress);
-            $this->entityManager->persist($newAddress);
-        }
-
-        if ($newEntity instanceof SluggableInterface) {
-            $this->entityManager->persist($newEntity);
-            if ($flush) {
-                $this->entityManager->flush();
-            }
-            $newEntity->setSlug(null);
-        }
-        $this->entityManager->persist($newEntity);
-        if ($flush) {
-            $this->entityManager->flush();
-        }
-
+        $this->eventDispatcher->dispatch(new EntityComponentEvent($newEntity), EntityComponentEvent::DUPLICATE_EVENT);
 
         return $newEntity;
     }

Controller/AbstractAdminController.php

 use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
 use EasyCorp\Bundle\EasyAdminBundle\Provider\AdminContextProvider;
 use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
+use EasyCorp\Bundle\EasyAdminBundle\Security\Permission;
+use Lc\SovBundle\Component\EntityComponent;
 use Lc\SovBundle\Doctrine\Extension\DevAliasInterface;
 use Lc\SovBundle\Doctrine\Extension\SeoInterface;
 use Lc\SovBundle\Doctrine\Extension\SortableInterface;
     public static function getSubscribedServices()
     {
         return array_merge(
-            parent::getSubscribedServices(),
-            [
-                'session' => SessionInterface::class,
-                'request' => RequestStack::class,
-                'em' => EntityManagerInterface::class,
-                'translator_admin' => TranslatorAdmin::class,
-                'filter_manager' => FilterManager::class,
-            ]
+                parent::getSubscribedServices(),
+                [
+                        'session' => SessionInterface::class,
+                        'request' => RequestStack::class,
+                        'em' => EntityManagerInterface::class,
+                        'translator_admin' => TranslatorAdmin::class,
+                        'filter_manager' => FilterManager::class,
+                ]
         );
     }
 
                     if ($entity !== null) {
                         if ($entity->getParent() !== null) {
                             $url = $adminUrlGenerator
-                                ->setController($context->getCrud()->getControllerFqcn())
-                                ->set('entityId', $entity->getParent()->getId())
-                                ->generateUrl();
+                                    ->setController($context->getCrud()->getControllerFqcn())
+                                    ->set('entityId', $entity->getParent()->getId())
+                                    ->generateUrl();
                             $action->setLinkUrl($url);
                         }
                     } else {
                     $entityId = $context->getRequest()->get('entityId');
                     if ($entityId != null) {
                         $url = $adminUrlGenerator
-                            ->setController($context->getCrud()->getControllerFqcn())
-                            ->setAction($action->getName())
-                            ->set('entityId', $entityId)
-                            ->generateUrl();
+                                ->setController($context->getCrud()->getControllerFqcn())
+                                ->setAction($action->getName())
+                                ->set('entityId', $entityId)
+                                ->generateUrl();
                         $action->setLinkUrl($url);
                     }
                 }
     {
         $entityClass = $this->getEntityFqcn();
         $paramListMaxResults = 'listMaxResults';
-        $paramSessionListMaxResults = $entityClass . '-' . $paramListMaxResults;
+        $paramSessionListMaxResults = $entityClass.'-'.$paramListMaxResults;
         $requestListMaxResults = $this->get('request')->getCurrentRequest()->get($paramListMaxResults);
 
         if ($requestListMaxResults) {
             $this->get('session')->set($paramSessionListMaxResults, $requestListMaxResults);
         }
         $maxResults = $this->get('session')->get($paramSessionListMaxResults) ? $this->get('session')->get(
-            $paramSessionListMaxResults
+                $paramSessionListMaxResults
         ) : 30;
 
         $crud->setPaginatorPageSize($maxResults);
     {
         if ($this->isInstanceOf(SeoInterface::class)) {
             return [
-                FormField::addPanel('seo')->setTemplateName('crud/field/generic'),
-                TextField::new('metaTitle')->setLabel('Meta Title')->setHelp(
-                    'Affiché dans les résultats de recherche Google'
-                )->hideOnIndex(),
-                TextareaField::new('metaDescription')->setLabel('Meta description')->setHelp(
-                    'Affiché dans les résultats de recherche Google'
-                )->hideOnIndex(),
-                CollectionField::new('oldUrls')
-                    ->setFormTypeOption('entry_type', TextType::class)->setLabel(
-                        'Anciennes urls du document'
+                    FormField::addPanel('seo')->setTemplateName('crud/field/generic'),
+                    TextField::new('metaTitle')->setLabel('Meta Title')->setHelp(
+                            'Affiché dans les résultats de recherche Google'
                     )->hideOnIndex(),
+                    TextareaField::new('metaDescription')->setLabel('Meta description')->setHelp(
+                            'Affiché dans les résultats de recherche Google'
+                    )->hideOnIndex(),
+                    CollectionField::new('oldUrls')
+                            ->setFormTypeOption('entry_type', TextType::class)->setLabel(
+                                    'Anciennes urls du document'
+                            )->hideOnIndex(),
             ];
         } else {
             return null;
     {
         if ($this->isInstanceOf(DevAliasInterface::class)) {
             return [
-                FormField::addPanel('configuration')->setTemplateName('crud/field/generic'),
-                TextField::new('devAlias')->hideOnIndex(),
+                    FormField::addPanel('configuration')->setTemplateName('crud/field/generic'),
+                    TextField::new('devAlias')->hideOnIndex(),
             ];
         } else {
             return null;
 
         $fields = FieldCollection::new($this->configureFields(Crud::PAGE_INDEX));
         $filters = $this->get(FilterFactory::class)->create(
-            $context->getCrud()->getFiltersConfig(),
-            $fields,
-            $context->getEntity()
+                $context->getCrud()->getFiltersConfig(),
+                $fields,
+                $context->getEntity()
         );
         $queryBuilder = $this->createIndexQueryBuilder($context->getSearch(), $context->getEntity(), $fields, $filters);
         $paginator = $this->get(PaginatorFactory::class)->create($queryBuilder);
         $this->get(EntityFactory::class)->processFieldsForAll($entities, $fields);
 
         $sortableForm = $this->createFormBuilder(array('entities', $paginator->getResults()))
-            ->add(
-                'entities',
-                CollectionType::class,
-                array(
-                    'required' => true,
-                    'allow_add' => true,
-                    'entry_type' => PositionType::class,
+                ->add(
+                        'entities',
+                        CollectionType::class,
+                        array(
+                                'required' => true,
+                                'allow_add' => true,
+                                'entry_type' => PositionType::class,
+                        )
                 )
-            )
-            ->getForm();
+                ->getForm();
 
         $entityManager = $this->getDoctrine()->getManagerForClass($this->getEntityFqcn());
         $repository = $entityManager->getRepository($this->getEntityFqcn());
             }
 
             $url = $this->get(AdminUrlGenerator::class)
-                ->setAction(Action::INDEX)
-                ->generateUrl();
+                    ->setAction(Action::INDEX)
+                    ->generateUrl();
             $this->addFlash('success', $this->translatorAdmin->transFlashMessage('sort'), array());
 
             return $this->redirect($url);
         }
 
         $responseParameters = $this->configureResponseParameters(
-            KeyValueStore::new(
-                [
-                    'pageName' => Crud::PAGE_INDEX,
-                    'templatePath' => '@LcSov/adminlte/crud/sort.html.twig',
-                    'entities' => $entities,
-                    'paginator' => $paginator,
-                    'global_actions' => array(),
-                    'batch_actions' => array(),
-                    'filters' => $filters,
-                    'sortable_form' => $sortableForm,
-                ]
-            )
+                KeyValueStore::new(
+                        [
+                                'pageName' => Crud::PAGE_INDEX,
+                                'templatePath' => '@LcSov/adminlte/crud/sort.html.twig',
+                                'entities' => $entities,
+                                'paginator' => $paginator,
+                                'global_actions' => array(),
+                                'batch_actions' => array(),
+                                'filters' => $filters,
+                                'sortable_form' => $sortableForm,
+                        ]
+                )
         );
         $responseParameters->set('fields', $this->configureFields('index'));
         $event = new AfterCrudActionEvent($context, $responseParameters);
         return $responseParameters;
     }
 
+    public function duplicate(AdminContext $context, EntityComponent $entityComponent, TranslatorAdmin $translatorAdmin, EntityManagerInterface $em)
+    {
+
+        if (!$this->isGranted(
+                Permission::EA_EXECUTE_ACTION,
+                ['action' => "duplicate", 'entity' => $context->getEntity()]
+        )) {
+            throw new ForbiddenActionException($context);
+        }
+
+        if (!$context->getEntity()->isAccessible()) {
+            throw new InsufficientEntityPermissionException($context);
+        }
+
+        $newEntity = $entityComponent->duplicateEntity($context->getEntity()->getInstance());
+        $em->create($newEntity);
+        $em->flush();
+
+        $url = $this->get(AdminUrlGenerator::class)
+                ->setAction(Action::EDIT)
+                ->setEntityId($newEntity->getId())
+                ->generateUrl();
+
+        $this->addFlash('success', $translatorAdmin->transFlashMessage('duplicate'), array());
+
+        return $this->redirect($url);
+    }
+
+
     public function createIndexQueryBuilder(
-        SearchDto $searchDto,
-        EntityDto $entityDto,
-        FieldCollection $fields,
-        FilterCollection $filters
+            SearchDto $searchDto,
+            EntityDto $entityDto,
+            FieldCollection $fields,
+            FilterCollection $filters
     ): QueryBuilder {
         $queryBuilder = parent::createIndexQueryBuilder(
-            $searchDto,
-            $entityDto,
-            $fields,
-            $filters
+                $searchDto,
+                $entityDto,
+                $fields,
+                $filters
         );
 
         //TOdo utiliser les repositoryQuery ?
         }
 
         $this->filtersForm = $this->createForm(
-            FiltersFormType::class,
-            null,
-            array(
-                'fields' => $fields,
-                'entity_dto' => $entityDto,
-                'entity_class' => $this->getEntityFqcn(),
-                'entity_name' => $entityDto->getName(),
-            )
+                FiltersFormType::class,
+                null,
+                array(
+                        'fields' => $fields,
+                        'entity_dto' => $entityDto,
+                        'entity_class' => $this->getEntityFqcn(),
+                        'entity_name' => $entityDto->getName(),
+                )
         );
 
         $filterManager = $this->get('filter_manager');
     }
 
     public function createSortQueryBuilder(
-        SearchDto $searchDto,
-        EntityDto $entityDto,
-        FieldCollection $fields,
-        FilterCollection $filters
+            SearchDto $searchDto,
+            EntityDto $entityDto,
+            FieldCollection $fields,
+            FilterCollection $filters
     ): QueryBuilder {
         $queryBuilder = $this->createIndexQueryBuilder($searchDto, $entityDto, $fields, $filters);
 
         $context = $this->get(AdminContextProvider::class)->getContext();
 
         return $context->getCrudControllers()->findCrudFqcnByEntityFqcn(
-            $this->get('em')->getEntityName($interface)
+                $this->get('em')->getEntityName($interface)
         );
     }
 
         return $actions;
     }
 
+    public function getDuplicateAction(): Action
+    {
+        $duplicateAction = Action::new(
+                'duplicate',
+                $this->get('translator_admin')->transAction('duplicate'),
+                'fa fa-fw fa-copy'
+        )
+                ->linkToCrudAction('duplicate')
+                ->setLabel($this->get('translator_admin')->transAction('duplicate'))
+                ->setCssClass('in-dropdown text-info action-confirm');
+
+        return $duplicateAction;
+    }
+
     public function buildIndexActions(Actions $actions): void
     {
+        $actions->add(Crud::PAGE_INDEX, $this->getDuplicateAction());
+
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_INDEX,
-            Action::NEW,
-            [
-                'icon' => 'plus',
-                'label' => $this->get('translator_admin')->transAction('create'),
-                'add_class' => 'btn-sm',
-            ]
+                $actions,
+                Crud::PAGE_INDEX,
+                Action::NEW,
+                [
+                        'icon' => 'plus',
+                        'label' => $this->get('translator_admin')->transAction('create'),
+                        'add_class' => 'btn-sm',
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_INDEX,
-            Action::EDIT,
-            [
-                'class' => 'btn btn-sm btn-primary',
-                'icon' => 'edit',
-                'label' => false,
-                'html_attributes' => array(
-                    'data-toggle' => 'tooltip',
-                    'title' => $this->get('translator_admin')->transAction('edit'),
-                ),
-            ]
+                $actions,
+                Crud::PAGE_INDEX,
+                Action::EDIT,
+                [
+                        'class' => 'btn btn-sm btn-primary',
+                        'icon' => 'edit',
+                        'label' => false,
+                        'html_attributes' => array(
+                                'data-toggle' => 'tooltip',
+                                'title' => $this->get('translator_admin')->transAction('edit'),
+                        ),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_INDEX,
-            Action::DETAIL,
-            [
-                'icon' => 'eye',
-                'add_class' => 'btn btn-sm btn-success',
-                'label' => false,
-                'html_attributes' => array(
-                    'data-toggle' => 'tooltip',
-                    'title' => $this->get('translator_admin')->transAction('detail'),
-                ),
-            ]
+                $actions,
+                Crud::PAGE_INDEX,
+                Action::DETAIL,
+                [
+                        'icon' => 'eye',
+                        'add_class' => 'btn btn-sm btn-success',
+                        'label' => false,
+                        'html_attributes' => array(
+                                'data-toggle' => 'tooltip',
+                                'title' => $this->get('translator_admin')->transAction('detail'),
+                        ),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_INDEX,
-            Action::DELETE,
-            [
-                'icon' => 'trash',
-                'dropdown' => true,
-                'label' => $this->get('translator_admin')->transAction('delete'),
-            ]
+                $actions,
+                Crud::PAGE_INDEX,
+                Action::DELETE,
+                [
+                        'icon' => 'trash',
+                        'dropdown' => true,
+                        'label' => $this->get('translator_admin')->transAction('delete'),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_INDEX,
-            Action::BATCH_DELETE,
-            [
-                'class' => 'btn btn-sm btn-danger',
-                'icon' => 'trash',
-                'label' => $this->get('translator_admin')->transAction('delete'),
-            ]
+                $actions,
+                Crud::PAGE_INDEX,
+                Action::BATCH_DELETE,
+                [
+                        'class' => 'btn btn-sm btn-danger',
+                        'icon' => 'trash',
+                        'label' => $this->get('translator_admin')->transAction('delete'),
+                ]
         );
     }
 
 
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::SAVE_AND_RETURN,
-            [
-                'add_class' => 'float-right',
-                'icon' => 'check',
-                'label' => $this->get('translator_admin')->transAction('save_and_return'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::SAVE_AND_RETURN,
+                [
+                        'add_class' => 'float-right',
+                        'icon' => 'check',
+                        'label' => $this->get('translator_admin')->transAction('save_and_return'),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::INDEX,
-            [
-                'icon' => 'chevron-left',
-                'class' => 'btn btn-link',
-                'label' => $this->get('translator_admin')->transAction('back_index'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::INDEX,
+                [
+                        'icon' => 'chevron-left',
+                        'class' => 'btn btn-link',
+                        'label' => $this->get('translator_admin')->transAction('back_index'),
+                ]
         );
 
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::SAVE_AND_CONTINUE,
-            [
-                'class' => 'btn btn-info float-right',
-                'label' => $this->get('translator_admin')->transAction('save_and_continue'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::SAVE_AND_CONTINUE,
+                [
+                        'class' => 'btn btn-info float-right',
+                        'label' => $this->get('translator_admin')->transAction('save_and_continue'),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::DELETE,
-            [
-                'icon' => 'trash',
-                'class' => 'btn btn-outline-danger action-delete',
-                'label' => $this->get('translator_admin')->transAction('delete'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::DELETE,
+                [
+                        'icon' => 'trash',
+                        'class' => 'btn btn-outline-danger action-delete',
+                        'label' => $this->get('translator_admin')->transAction('delete'),
+                ]
         );
     }
 
         $actions->add(Crud::PAGE_NEW, Action::INDEX);
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::SAVE_AND_RETURN,
-            [
-                'add_class' => 'float-right',
-                'icon' => 'check',
-                'label' => $this->get('translator_admin')->transAction('save_and_return'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::SAVE_AND_RETURN,
+                [
+                        'add_class' => 'float-right',
+                        'icon' => 'check',
+                        'label' => $this->get('translator_admin')->transAction('save_and_return'),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::INDEX,
-            [
-                'icon' => 'chevron-left',
-                'class' => 'btn btn-link',
-                'label' => $this->get('translator_admin')->transAction('back_index'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::INDEX,
+                [
+                        'icon' => 'chevron-left',
+                        'class' => 'btn btn-link',
+                        'label' => $this->get('translator_admin')->transAction('back_index'),
+                ]
         );
 
         $this->actionUpdate(
-            $actions,
-            Crud::PAGE_EDIT,
-            Action::SAVE_AND_ADD_ANOTHER,
-            [
-                'class' => 'btn btn-info float-right',
-                'label' => $this->get('translator_admin')->transAction('save_and_add_another'),
-            ]
+                $actions,
+                Crud::PAGE_EDIT,
+                Action::SAVE_AND_ADD_ANOTHER,
+                [
+                        'class' => 'btn btn-info float-right',
+                        'label' => $this->get('translator_admin')->transAction('save_and_add_another'),
+                ]
         );
     }
 
     {
         if ($this->isInstanceOf(TranslatableInterface::class)) {
             $actions->update(
-                Crud::PAGE_INDEX,
-                Action::EDIT,
-                function (Action $action) {
-                    $action->setTemplatePath('@LcSov/adminlte/crud/action/translatable.html.twig');
+                    Crud::PAGE_INDEX,
+                    Action::EDIT,
+                    function (Action $action) {
+                        $action->setTemplatePath('@LcSov/adminlte/crud/action/translatable.html.twig');
 
-                    return $action;
-                }
+                        return $action;
+                    }
             );
         }
     }
     {
         if ($this->isInstanceOf(SortableInterface::class)) {
             $sortAction = Action::new('sort', $this->get('translator_admin')->transAction('sort'), 'fa fa-sort')
-                ->linkToCrudAction('sort')
-                ->setCssClass('btn btn-sm btn-success')
-                ->createAsGlobalAction();
+                    ->linkToCrudAction('sort')
+                    ->setCssClass('btn btn-sm btn-success')
+                    ->createAsGlobalAction();
 
             $actions->add(Crud::PAGE_INDEX, $sortAction);
         }
     {
         if ($this->isInstanceOf(TreeInterface::class)) {
             $indexChildAction = Action::new(
-                'index_children',
-                $this->get('translator_admin')->transAction('index_children'),
-                'fa fa-list'
+                    'index_children',
+                    $this->get('translator_admin')->transAction('index_children'),
+                    'fa fa-list'
             )
-                ->linkToCrudAction(Action::INDEX)
-                ->setLabel('')
-                ->setHtmlAttributes(array('data-toggle' => 'tooltip', 'title' => 'Afficher les enfants'))
-                ->setTemplatePath('@LcSov/adminlte/crud/action/index_children.html.twig')
-                ->setCssClass('btn btn-sm btn-success');
+                    ->linkToCrudAction(Action::INDEX)
+                    ->setLabel('')
+                    ->setHtmlAttributes(array('data-toggle' => 'tooltip', 'title' => 'Afficher les enfants'))
+                    ->setTemplatePath('@LcSov/adminlte/crud/action/index_children.html.twig')
+                    ->setCssClass('btn btn-sm btn-success');
 
             $backParentAction = Action::new(
-                'index_parent',
-                $this->get('translator_admin')->transAction('index_parent'),
-                'fa fa-chevron-left'
+                    'index_parent',
+                    $this->get('translator_admin')->transAction('index_parent'),
+                    'fa fa-chevron-left'
             )
-                ->linkToCrudAction(Action::INDEX)
-                ->setCssClass('btn btn-sm btn-info')
-                ->createAsGlobalAction();
+                    ->linkToCrudAction(Action::INDEX)
+                    ->setCssClass('btn btn-sm btn-info')
+                    ->createAsGlobalAction();
 
             $actions->add(Crud::PAGE_INDEX, $backParentAction);
             $actions->add(Crud::PAGE_INDEX, $indexChildAction);
     {
         if ($actions->getAsDto('actions')->getAction($crudActionName, $actionName)) {
             $actions->update(
-                $crudActionName,
-                $actionName,
-                function (Action $action) use ($button) {
-                    if (isset($button['add_class'])) {
-                        $action->addCssClass($button['add_class']);
-                    }
+                    $crudActionName,
+                    $actionName,
+                    function (Action $action) use ($button) {
+                        if (isset($button['add_class'])) {
+                            $action->addCssClass($button['add_class']);
+                        }
 
-                    if (isset($button['class'])) {
-                        $action->setCssClass($button['class']);
-                    }
+                        if (isset($button['class'])) {
+                            $action->setCssClass($button['class']);
+                        }
 
-                    if (isset($button['icon'])) {
-                        $action->setIcon('fa fa-' . $button['icon']);
-                    }
+                        if (isset($button['icon'])) {
+                            $action->setIcon('fa fa-'.$button['icon']);
+                        }
 
-                    if (isset($button['label'])) {
-                        $action->setLabel($button['label']);
-                    }
+                        if (isset($button['label'])) {
+                            $action->setLabel($button['label']);
+                        }
 
-                    if (isset($button['dropdown']) && $button['dropdown']) {
-                        $action->addCssClass('in-dropdown');
-                    }
+                        if (isset($button['dropdown']) && $button['dropdown']) {
+                            $action->addCssClass('in-dropdown');
+                        }
 
-                    if (isset($button['html_attributes']) && $button['html_attributes']) {
-                        $action->setHtmlAttributes($button['html_attributes']);
-                    }
+                        if (isset($button['html_attributes']) && $button['html_attributes']) {
+                            $action->setHtmlAttributes($button['html_attributes']);
+                        }
 
-                    return $action;
-                }
+                        return $action;
+                    }
             );
         }
     }
     public function autocompleteFilter(AdminContext $context): JsonResponse
     {
         $queryBuilder = $this->createIndexQueryBuilder(
-            $context->getSearch(),
-            $context->getEntity(),
-            FieldCollection::new([]),
-            FilterCollection::new()
+                $context->getSearch(),
+                $context->getEntity(),
+                FieldCollection::new([]),
+                FilterCollection::new()
         );
         $autocompleteContext = $context->getRequest()->get(AssociationField::PARAM_AUTOCOMPLETE_CONTEXT);
 
         /** @var CrudControllerInterface $controller */
         $controller = $this->get(ControllerFactory::class)->getCrudControllerInstance(
-            $autocompleteContext[EA::CRUD_CONTROLLER_FQCN],
-            Action::INDEX,
-            $context->getRequest()
+                $autocompleteContext[EA::CRUD_CONTROLLER_FQCN],
+                Action::INDEX,
+                $context->getRequest()
         );
         /** @var FieldDto $field */
         $field = FieldCollection::new(
-            $controller->configureFields($autocompleteContext['originatingPage'])
+                $controller->configureFields($autocompleteContext['originatingPage'])
         )->getByProperty($autocompleteContext['propertyName']);
 
         $filterManager = $this->get('filter_manager');
         if ($filterManager->isRelationField($field->getProperty())) {
             $queryBuilder->select($autocompleteContext['propertyName']);
         } else {
-            $queryBuilder->select('entity.' . $autocompleteContext['propertyName']);
+            $queryBuilder->select('entity.'.$autocompleteContext['propertyName']);
         }
 
         $responses = array();

Doctrine/EntityManager.php

         return new $entityName;
     }
 
-    public function create(EntityInterface $entity): self
+    public function create(EntityInterface $entity, bool $dispatchEvent = true): self
     {
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_CREATE_EVENT);
+        if($dispatchEvent) {
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_CREATE_EVENT);
+        }
         $this->persist($entity);
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_CREATE_EVENT);
-
+        if($dispatchEvent) {
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_CREATE_EVENT);
+        }
         return $this;
     }
 
-    public function update(EntityInterface $entity): self
+    public function update(EntityInterface $entity, bool $dispatchEvent = true): self
     {
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_UPDATE_EVENT);
+        if($dispatchEvent){
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_UPDATE_EVENT);
+        }
         $this->persist($entity);
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_UPDATE_EVENT);
-
+        if($dispatchEvent) {
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_UPDATE_EVENT);
+        }
         return $this;
     }
 
-    public function delete(EntityInterface $entity): self
+    public function delete(EntityInterface $entity, bool $dispatchEvent = true): self
     {
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_DELETE_EVENT);
-
+        if($dispatchEvent) {
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::PRE_DELETE_EVENT);
+        }
         $this->remove($entity);
-        $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_DELETE_EVENT);
-
+        if($dispatchEvent) {
+            $this->eventDispatcher->dispatch(new EntityManagerEvent($entity), EntityManagerEvent::POST_DELETE_EVENT);
+        }
         return $this;
     }
 

Doctrine/Extension/ClearIdTrait.php

+<?php
+
+namespace Lc\SovBundle\Doctrine\Extension;
+
+trait ClearIdTrait
+{
+
+    public function clearId($id): self
+    {
+        $this->id = $id;
+
+        return $this;
+    }
+
+}

Doctrine/Extension/SluggableTrait.php

 {
     /**
      * @ORM\Column(type="string", length=255)
-     * @Gedmo\Slug(fields={"title"})
+     * @Gedmo\Slug(fields={"title"}, unique=true)
      */
     protected $slug;
 

Event/EntityComponentEvent.php

+<?php
+
+namespace Lc\SovBundle\Event;
+
+use Lc\SovBundle\Doctrine\EntityInterface;
+use Symfony\Contracts\EventDispatcher\Event;
+
+/**
+ * class EntityEvent.
+ *
+ * @author Simon Vieille <simon@deblan.fr>
+ */
+class EntityComponentEvent extends Event
+{
+    const DUPLICATE_EVENT = 'entity_component_event.duplicate';
+
+    protected EntityInterface $entity;
+
+    public function __construct(EntityInterface $entity)
+    {
+        $this->entity = $entity;
+    }
+
+    public function getEntity(): EntityInterface
+    {
+        return $this->entity;
+    }
+}

EventSubscriber/SluggablePropertyEventSubscriber.php

+<?php
+
+namespace Lc\SovBundle\EventSubscriber;
+
+use Doctrine\ORM\EntityManagerInterface;
+
+use Lc\SovBundle\Doctrine\EntityInterface;
+use Lc\SovBundle\Doctrine\Extension\SluggableInterface;
+use Lc\SovBundle\Doctrine\Extension\SortableInterface;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
+use Lc\SovBundle\Doctrine\Extension\TreeInterface;
+use Lc\SovBundle\Event\EntityComponentEvent;
+use Lc\SovBundle\Event\EntityManager\EntityManagerEvent;
+use Lc\SovBundle\Repository\AbstractRepositoryInterface;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+class SluggablePropertyEventSubscriber implements EventSubscriberInterface
+{
+    protected $em;
+    protected $adminUrlGenerator;
+
+    public function __construct(EntityManagerInterface $entityManager)
+    {
+        $this->em = $entityManager;
+    }
+
+    public static function getSubscribedEvents()
+    {
+        return [
+                EntityComponentEvent::DUPLICATE_EVENT => ['setSluggablePropertyDuplicateEvent'],
+                EntityManagerEvent::POST_UPDATE_EVENT => ['setSluggablePropertyUpdateEvent'],
+        ];
+    }
+
+    public function setSluggablePropertyDuplicateEvent(EntityComponentEvent $event)
+    {
+        $entity = $event->getEntity();
+        if ($entity instanceof SluggableInterface) {
+            $entity->clearId(null);
+            $entity->setSlug(null);
+        }
+    }
+
+    public function setSluggablePropertyUpdateEvent(EntityManagerEvent $event)
+    {
+        $entity = $event->getEntity();
+        if ($entity instanceof SluggableInterface) {
+            $entity->setSlug(null);
+        }
+    }
+
+}

EventSubscriber/CommonPropertyEventSubscriber.php → EventSubscriber/SortablePropertyEventSubscriber.php

 use Lc\SovBundle\Repository\AbstractRepositoryInterface;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 
-class CommonPropertyEventSubscriber implements EventSubscriberInterface
+class SortablePropertyEventSubscriber implements EventSubscriberInterface
 {
     protected $em;
     protected $adminUrlGenerator;

Repository/AbstractRepository.php

         return $query;
     }
 
-    public function findSimilarSlug($merchant)
+    public function findBySimilarSlug($slug)
     {
         $qb = $this->createQueryBuilder('entity')
-                ->select('entity.id, COUNT(entity.slug) as niche')
+                ->select('COUNT(entity.slug) as totalSimilar')
                 ->andWhere('entity.status>=0')
+                ->andWhere('entity.slug LIKE :slug')
+                ->setParameter('slug', $slug)
                 ->groupBy('entity.slug')
-                ->having('COUNT(entity.slug) >1');
+                ->having('COUNT(entity.slug) >=1');
 
-        return $qb->getQuery()->getResult();
+        return $qb->getQuery()->getOneOrNullResult();
     }
 
     public function findAll()

Resources/assets/app/adminlte/main/init.js

     SovNotification.init();
 
     SovWidgets.setDateRange();
-    SovWidgets.setAutoCompleteField();
+
+    SovTools.log('ncihe');
+    $('.btn-confirm-js, .action-confirm').click(function () {
+        return confirm('Êtes-vous sûr de vouloir réaliser cette action ?');
+    });
 
     /* Tooltip */
     $('[data-toggle="tooltip"]').tooltip();
         }
     }
 
+    SovWidgets.setAutoCompleteField();
+
 
 });

Resources/assets/functions/widgets.js

                 autocompleteFields.each(function () {
                         var $this = $(this),
                             url = $this.data('lc-autocomplete-url');
-
+SovTools.log($this);
                         $this.autoComplete({
                                 noResultsText: 'Aucun résultat n\'a été trouvé.',
                                 resolverSettings: {

Resources/translations/admin.fr.yaml

   change: Changer
   detail: Voir
   send: Envoyer
+  duplicate: Dupliquer
+  cancel: Annuler
   index_children: Afficher les enfants
   index_parent: Retour au parent
   back_index: Retour à la liste
   update: Le contenu "%name%" a été mis à jour avec succès.
   delete: Le contenu "%name%" a été supprimé avec succès.
   sort: Position modifiée
+  duplicate: Le document a bien été dupliqué
 
 entity:
   User:

Translation/TranslatorAdmin.php

         return $this->trans('menu.' . $menu);
     }
 
-    public function transFlashMessage($name)
+    public function transFlashMessage($name,  $params = [])
     {
-        return $this->trans('flash_message.' . $name);
+        return $this->trans('flash_message.' . $name, $params);
     }
 
     public function transField($fieldName, $entityClass): string