add generated entities/forms/factories/queries/cruds

src/Controller/EstablishmentAdminController.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace App\Controller;
+
+use App\Core\Controller\Admin\Crud\CrudController;
+use App\Core\Crud\CrudConfiguration;
+use App\Core\Crud\Field;
+use App\Core\Entity\EntityInterface;
+use App\Core\Manager\EntityManager;
+use App\Entity\Establishment as Entity;
+use App\Factory\EstablishmentFactory as Factory;
+use App\Form\EstablishmentType as Type;
+use App\Repository\EstablishmentRepositoryQuery as RepositoryQuery;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\Routing\Annotation\Route;
+
+class EstablishmentAdminController extends CrudController
+{
+    /**
+     * @Route("/admin/establishment/{page}", name="admin_establishment_index", methods={"GET"}, requirements={"page":"\d+"})
+     */
+    public function index(RepositoryQuery $query, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doIndex($page, $query, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/establishment/new", name="admin_establishment_new", methods={"GET", "POST"})
+     */
+    public function new(Factory $factory, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doNew($factory->create(), $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/establishment/show/{entity}", name="admin_establishment_show", methods={"GET"})
+     */
+    public function show(Entity $entity): Response
+    {
+        return $this->doShow($entity);
+    }
+
+    /**
+     * @Route("/admin/establishment/filter", name="admin_establishment_filter", methods={"GET"})
+     */
+    public function filter(Session $session): Response
+    {
+        return $this->doFilter($session);
+    }
+
+    /**
+     * @Route("/admin/establishment/edit/{entity}", name="admin_establishment_edit", methods={"GET", "POST"})
+     */
+    public function edit(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doEdit($entity, $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/establishment/sort/{page}", name="admin_establishment_sort", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function sort(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doSort($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/establishment/batch/{page}", name="admin_establishment_batch", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function batch(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doBatch($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/establishment/delete/{entity}", name="admin_establishment_delete", methods={"DELETE"})
+     */
+    public function delete(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doDelete($entity, $entityManager, $request);
+    }
+
+    protected function getConfiguration(): CrudConfiguration
+    {
+        return CrudConfiguration::create()
+            ->setPageTitle('index', 'List of App\Entity\Establishment')
+            ->setPageTitle('edit', 'Edition of {id}')
+            ->setPageTitle('new', 'New App\Entity\Establishment')
+            ->setPageTitle('show', 'View of {id}')
+
+            ->setPageRoute('index', 'admin_establishment_index')
+            ->setPageRoute('new', 'admin_establishment_new')
+            ->setPageRoute('edit', 'admin_establishment_edit')
+            ->setPageRoute('show', 'admin_establishment_show')
+            ->setPageRoute('sort', 'admin_establishment_sort')
+            ->setPageRoute('batch', 'admin_establishment_batch')
+            ->setPageRoute('delete', 'admin_establishment_delete')
+            ->setPageRoute('filter', 'admin_establishment_filter')
+
+            ->setForm('edit', Type::class, [])
+            ->setForm('new', Type::class)
+            // ->setForm('filter', Type::class)
+
+            // ->setMaxPerPage('index', 20)
+
+            // ->setIsSortableCollection('index', false)
+            // ->setSortableCollectionProperty('sortOrder')
+
+            // ->setAction('index', 'new', true)
+            // ->setAction('index', 'show', true)
+            // ->setAction('index', 'edit', true)
+            // ->setAction('index', 'delete', true)
+
+            // ->setAction('edit', 'back', true)
+            // ->setAction('edit', 'show', true)
+            // ->setAction('edit', 'delete', true)
+
+            // ->setAction('show', 'back', true)
+            // ->setAction('show', 'edit', true)
+
+            // ->setField('index', 'Label', Field\TextField::class, [
+            //     'property' => 'label',
+            // ])
+
+            // ->setBatchAction('index', 'delete', 'Delete', function(EntityInterface $entity, EntityManager $manager) {
+            //     $manager->delete($entity);
+            // })
+        ;
+    }
+
+    protected function getSection(): string
+    {
+        return 'establishment';
+    }
+}

src/Controller/InterventionAdminController.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace App\Controller;
+
+use App\Core\Controller\Admin\Crud\CrudController;
+use App\Core\Crud\CrudConfiguration;
+use App\Core\Crud\Field;
+use App\Core\Entity\EntityInterface;
+use App\Core\Manager\EntityManager;
+use App\Entity\Intervention as Entity;
+use App\Factory\InterventionFactory as Factory;
+use App\Form\InterventionType as Type;
+use App\Repository\InterventionRepositoryQuery as RepositoryQuery;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\Routing\Annotation\Route;
+
+class InterventionAdminController extends CrudController
+{
+    /**
+     * @Route("/admin/intervention/{page}", name="admin_intervention_index", methods={"GET"}, requirements={"page":"\d+"})
+     */
+    public function index(RepositoryQuery $query, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doIndex($page, $query, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/intervention/new", name="admin_intervention_new", methods={"GET", "POST"})
+     */
+    public function new(Factory $factory, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doNew($factory->create(), $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/intervention/show/{entity}", name="admin_intervention_show", methods={"GET"})
+     */
+    public function show(Entity $entity): Response
+    {
+        return $this->doShow($entity);
+    }
+
+    /**
+     * @Route("/admin/intervention/filter", name="admin_intervention_filter", methods={"GET"})
+     */
+    public function filter(Session $session): Response
+    {
+        return $this->doFilter($session);
+    }
+
+    /**
+     * @Route("/admin/intervention/edit/{entity}", name="admin_intervention_edit", methods={"GET", "POST"})
+     */
+    public function edit(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doEdit($entity, $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/intervention/sort/{page}", name="admin_intervention_sort", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function sort(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doSort($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/intervention/batch/{page}", name="admin_intervention_batch", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function batch(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doBatch($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/intervention/delete/{entity}", name="admin_intervention_delete", methods={"DELETE"})
+     */
+    public function delete(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doDelete($entity, $entityManager, $request);
+    }
+
+    protected function getConfiguration(): CrudConfiguration
+    {
+        return CrudConfiguration::create()
+            ->setPageTitle('index', 'List of App\Entity\Intervention')
+            ->setPageTitle('edit', 'Edition of {id}')
+            ->setPageTitle('new', 'New App\Entity\Intervention')
+            ->setPageTitle('show', 'View of {id}')
+
+            ->setPageRoute('index', 'admin_intervention_index')
+            ->setPageRoute('new', 'admin_intervention_new')
+            ->setPageRoute('edit', 'admin_intervention_edit')
+            ->setPageRoute('show', 'admin_intervention_show')
+            ->setPageRoute('sort', 'admin_intervention_sort')
+            ->setPageRoute('batch', 'admin_intervention_batch')
+            ->setPageRoute('delete', 'admin_intervention_delete')
+            ->setPageRoute('filter', 'admin_intervention_filter')
+
+            ->setForm('edit', Type::class, [])
+            ->setForm('new', Type::class)
+            // ->setForm('filter', Type::class)
+
+            // ->setMaxPerPage('index', 20)
+
+            // ->setIsSortableCollection('index', false)
+            // ->setSortableCollectionProperty('sortOrder')
+
+            // ->setAction('index', 'new', true)
+            // ->setAction('index', 'show', true)
+            // ->setAction('index', 'edit', true)
+            // ->setAction('index', 'delete', true)
+
+            // ->setAction('edit', 'back', true)
+            // ->setAction('edit', 'show', true)
+            // ->setAction('edit', 'delete', true)
+
+            // ->setAction('show', 'back', true)
+            // ->setAction('show', 'edit', true)
+
+            // ->setField('index', 'Label', Field\TextField::class, [
+            //     'property' => 'label',
+            // ])
+
+            // ->setBatchAction('index', 'delete', 'Delete', function(EntityInterface $entity, EntityManager $manager) {
+            //     $manager->delete($entity);
+            // })
+        ;
+    }
+
+    protected function getSection(): string
+    {
+        return 'intervention';
+    }
+}

src/Controller/SpeakerAdminController.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace App\Controller;
+
+use App\Core\Controller\Admin\Crud\CrudController;
+use App\Core\Crud\CrudConfiguration;
+use App\Core\Crud\Field;
+use App\Core\Entity\EntityInterface;
+use App\Core\Manager\EntityManager;
+use App\Entity\Speaker as Entity;
+use App\Factory\SpeakerFactory as Factory;
+use App\Form\SpeakerType as Type;
+use App\Repository\SpeakerRepositoryQuery as RepositoryQuery;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\Routing\Annotation\Route;
+
+class SpeakerAdminController extends CrudController
+{
+    /**
+     * @Route("/admin/speaker/{page}", name="admin_speaker_index", methods={"GET"}, requirements={"page":"\d+"})
+     */
+    public function index(RepositoryQuery $query, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doIndex($page, $query, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/speaker/new", name="admin_speaker_new", methods={"GET", "POST"})
+     */
+    public function new(Factory $factory, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doNew($factory->create(), $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/speaker/show/{entity}", name="admin_speaker_show", methods={"GET"})
+     */
+    public function show(Entity $entity): Response
+    {
+        return $this->doShow($entity);
+    }
+
+    /**
+     * @Route("/admin/speaker/filter", name="admin_speaker_filter", methods={"GET"})
+     */
+    public function filter(Session $session): Response
+    {
+        return $this->doFilter($session);
+    }
+
+    /**
+     * @Route("/admin/speaker/edit/{entity}", name="admin_speaker_edit", methods={"GET", "POST"})
+     */
+    public function edit(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doEdit($entity, $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/speaker/sort/{page}", name="admin_speaker_sort", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function sort(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doSort($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/speaker/batch/{page}", name="admin_speaker_batch", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function batch(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doBatch($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/speaker/delete/{entity}", name="admin_speaker_delete", methods={"DELETE"})
+     */
+    public function delete(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doDelete($entity, $entityManager, $request);
+    }
+
+    protected function getConfiguration(): CrudConfiguration
+    {
+        return CrudConfiguration::create()
+            ->setPageTitle('index', 'List of App\Entity\Speaker')
+            ->setPageTitle('edit', 'Edition of {id}')
+            ->setPageTitle('new', 'New App\Entity\Speaker')
+            ->setPageTitle('show', 'View of {id}')
+
+            ->setPageRoute('index', 'admin_speaker_index')
+            ->setPageRoute('new', 'admin_speaker_new')
+            ->setPageRoute('edit', 'admin_speaker_edit')
+            ->setPageRoute('show', 'admin_speaker_show')
+            ->setPageRoute('sort', 'admin_speaker_sort')
+            ->setPageRoute('batch', 'admin_speaker_batch')
+            ->setPageRoute('delete', 'admin_speaker_delete')
+            ->setPageRoute('filter', 'admin_speaker_filter')
+
+            ->setForm('edit', Type::class, [])
+            ->setForm('new', Type::class)
+            // ->setForm('filter', Type::class)
+
+            // ->setMaxPerPage('index', 20)
+
+            // ->setIsSortableCollection('index', false)
+            // ->setSortableCollectionProperty('sortOrder')
+
+            // ->setAction('index', 'new', true)
+            // ->setAction('index', 'show', true)
+            // ->setAction('index', 'edit', true)
+            // ->setAction('index', 'delete', true)
+
+            // ->setAction('edit', 'back', true)
+            // ->setAction('edit', 'show', true)
+            // ->setAction('edit', 'delete', true)
+
+            // ->setAction('show', 'back', true)
+            // ->setAction('show', 'edit', true)
+
+            // ->setField('index', 'Label', Field\TextField::class, [
+            //     'property' => 'label',
+            // ])
+
+            // ->setBatchAction('index', 'delete', 'Delete', function(EntityInterface $entity, EntityManager $manager) {
+            //     $manager->delete($entity);
+            // })
+        ;
+    }
+
+    protected function getSection(): string
+    {
+        return 'speaker';
+    }
+}

src/Controller/ToolAdminController.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace App\Controller;
+
+use App\Core\Controller\Admin\Crud\CrudController;
+use App\Core\Crud\CrudConfiguration;
+use App\Core\Crud\Field;
+use App\Core\Entity\EntityInterface;
+use App\Core\Manager\EntityManager;
+use App\Entity\Tool as Entity;
+use App\Factory\ToolFactory as Factory;
+use App\Form\ToolType as Type;
+use App\Repository\ToolRepositoryQuery as RepositoryQuery;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\Routing\Annotation\Route;
+
+class ToolAdminController extends CrudController
+{
+    /**
+     * @Route("/admin/tool/{page}", name="admin_tool_index", methods={"GET"}, requirements={"page":"\d+"})
+     */
+    public function index(RepositoryQuery $query, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doIndex($page, $query, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/tool/new", name="admin_tool_new", methods={"GET", "POST"})
+     */
+    public function new(Factory $factory, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doNew($factory->create(), $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/tool/show/{entity}", name="admin_tool_show", methods={"GET"})
+     */
+    public function show(Entity $entity): Response
+    {
+        return $this->doShow($entity);
+    }
+
+    /**
+     * @Route("/admin/tool/filter", name="admin_tool_filter", methods={"GET"})
+     */
+    public function filter(Session $session): Response
+    {
+        return $this->doFilter($session);
+    }
+
+    /**
+     * @Route("/admin/tool/edit/{entity}", name="admin_tool_edit", methods={"GET", "POST"})
+     */
+    public function edit(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doEdit($entity, $entityManager, $request);
+    }
+
+    /**
+     * @Route("/admin/tool/sort/{page}", name="admin_tool_sort", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function sort(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doSort($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/tool/batch/{page}", name="admin_tool_batch", methods={"POST"}, requirements={"page":"\d+"})
+     */
+    public function batch(RepositoryQuery $query, EntityManager $entityManager, Request $request, Session $session, int $page = 1): Response
+    {
+        return $this->doBatch($page, $query, $entityManager, $request, $session);
+    }
+
+    /**
+     * @Route("/admin/tool/delete/{entity}", name="admin_tool_delete", methods={"DELETE"})
+     */
+    public function delete(Entity $entity, EntityManager $entityManager, Request $request): Response
+    {
+        return $this->doDelete($entity, $entityManager, $request);
+    }
+
+    protected function getConfiguration(): CrudConfiguration
+    {
+        return CrudConfiguration::create()
+            ->setPageTitle('index', 'List of App\Entity\Tool')
+            ->setPageTitle('edit', 'Edition of {id}')
+            ->setPageTitle('new', 'New App\Entity\Tool')
+            ->setPageTitle('show', 'View of {id}')
+
+            ->setPageRoute('index', 'admin_tool_index')
+            ->setPageRoute('new', 'admin_tool_new')
+            ->setPageRoute('edit', 'admin_tool_edit')
+            ->setPageRoute('show', 'admin_tool_show')
+            ->setPageRoute('sort', 'admin_tool_sort')
+            ->setPageRoute('batch', 'admin_tool_batch')
+            ->setPageRoute('delete', 'admin_tool_delete')
+            ->setPageRoute('filter', 'admin_tool_filter')
+
+            ->setForm('edit', Type::class, [])
+            ->setForm('new', Type::class)
+            // ->setForm('filter', Type::class)
+
+            // ->setMaxPerPage('index', 20)
+
+            // ->setIsSortableCollection('index', false)
+            // ->setSortableCollectionProperty('sortOrder')
+
+            // ->setAction('index', 'new', true)
+            // ->setAction('index', 'show', true)
+            // ->setAction('index', 'edit', true)
+            // ->setAction('index', 'delete', true)
+
+            // ->setAction('edit', 'back', true)
+            // ->setAction('edit', 'show', true)
+            // ->setAction('edit', 'delete', true)
+
+            // ->setAction('show', 'back', true)
+            // ->setAction('show', 'edit', true)
+
+            // ->setField('index', 'Label', Field\TextField::class, [
+            //     'property' => 'label',
+            // ])
+
+            // ->setBatchAction('index', 'delete', 'Delete', function(EntityInterface $entity, EntityManager $manager) {
+            //     $manager->delete($entity);
+            // })
+        ;
+    }
+
+    protected function getSection(): string
+    {
+        return 'tool';
+    }
+}

src/Entity/Establishment.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace App\Entity;
+
+use App\Core\Entity\EntityInterface;
+use App\Repository\EstablishmentRepository;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity(repositoryClass=EstablishmentRepository::class)
+ */
+class Establishment implements EntityInterface
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     */
+    private $id;
+
+    /**
+     * @ORM\Column(type="string", length=255)
+     */
+    private $name;
+
+    /**
+     * @ORM\Column(type="string", length=255)
+     */
+    private $address;
+
+    /**
+     * @ORM\Column(type="string", length=10)
+     */
+    private $zipCode;
+
+    /**
+     * @ORM\Column(type="string", length=100)
+     */
+    private $city;
+
+    /**
+     * @ORM\OneToMany(targetEntity=Intervention::class, mappedBy="establishment")
+     */
+    private $interventions;
+
+    public function __construct()
+    {
+        $this->interventions = new ArrayCollection();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getName(): ?string
+    {
+        return $this->name;
+    }
+
+    public function setName(string $name): self
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    public function getAddress(): ?string
+    {
+        return $this->address;
+    }
+
+    public function setAddress(string $address): self
+    {
+        $this->address = $address;
+
+        return $this;
+    }
+
+    public function getZipCode(): ?string
+    {
+        return $this->zipCode;
+    }
+
+    public function setZipCode(string $zipCode): self
+    {
+        $this->zipCode = $zipCode;
+
+        return $this;
+    }
+
+    public function getCity(): ?string
+    {
+        return $this->city;
+    }
+
+    public function setCity(string $city): self
+    {
+        $this->city = $city;
+
+        return $this;
+    }
+
+    /**
+     * @return Collection<int, Intervention>
+     */
+    public function getInterventions(): Collection
+    {
+        return $this->interventions;
+    }
+
+    public function addIntervention(Intervention $intervention): self
+    {
+        if (!$this->interventions->contains($intervention)) {
+            $this->interventions[] = $intervention;
+            $intervention->setEstablishment($this);
+        }
+
+        return $this;
+    }
+
+    public function removeIntervention(Intervention $intervention): self
+    {
+        if ($this->interventions->removeElement($intervention)) {
+            // set the owning side to null (unless already changed)
+            if ($intervention->getEstablishment() === $this) {
+                $intervention->setEstablishment(null);
+            }
+        }
+
+        return $this;
+    }
+}

src/Entity/Intervention.php

@@ -0,0 +1,261 @@
+<?php
+
+namespace App\Entity;
+
+use App\Core\Entity\EntityInterface;
+use App\Repository\InterventionRepository;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity(repositoryClass=InterventionRepository::class)
+ */
+class Intervention implements EntityInterface
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     */
+    private $id;
+
+    /**
+     * @ORM\ManyToMany(targetEntity=Speaker::class, inversedBy="interventions")
+     */
+    private $speaker;
+
+    /**
+     * @ORM\ManyToOne(targetEntity=Establishment::class, inversedBy="interventions")
+     */
+    private $establishment;
+
+    /**
+     * @ORM\Column(type="string", length=255, nullable=true)
+     */
+    private $activityReference;
+
+    /**
+     * @ORM\Column(type="date", nullable=true)
+     */
+    private $date;
+
+    /**
+     * @ORM\Column(type="integer", nullable=true)
+     */
+    private $groups;
+
+    /**
+     * @ORM\Column(type="string", length=255, nullable=true)
+     */
+    private $levels;
+
+    /**
+     * @ORM\Column(type="text", nullable=true)
+     */
+    private $themes;
+
+    /**
+     * @ORM\Column(type="text", nullable=true)
+     */
+    private $content;
+
+    /**
+     * @ORM\ManyToMany(targetEntity=Tool::class, inversedBy="interventions")
+     */
+    private $tools;
+
+    /**
+     * @ORM\Column(type="text", nullable=true)
+     */
+    private $toolsDetails;
+
+    /**
+     * @ORM\Column(type="text", nullable=true)
+     */
+    private $feedback;
+
+    /**
+     * @ORM\Column(type="text", nullable=true)
+     */
+    private $vigilantPoints;
+
+    public function __construct()
+    {
+        $this->speaker = new ArrayCollection();
+        $this->tools = new ArrayCollection();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    /**
+     * @return Collection<int, Speaker>
+     */
+    public function getSpeaker(): Collection
+    {
+        return $this->speaker;
+    }
+
+    public function addSpeaker(Speaker $speaker): self
+    {
+        if (!$this->speaker->contains($speaker)) {
+            $this->speaker[] = $speaker;
+        }
+
+        return $this;
+    }
+
+    public function removeSpeaker(Speaker $speaker): self
+    {
+        $this->speaker->removeElement($speaker);
+
+        return $this;
+    }
+
+    public function getEstablishment(): ?Establishment
+    {
+        return $this->establishment;
+    }
+
+    public function setEstablishment(?Establishment $establishment): self
+    {
+        $this->establishment = $establishment;
+
+        return $this;
+    }
+
+    public function getActivityReference(): ?string
+    {
+        return $this->activityReference;
+    }
+
+    public function setActivityReference(?string $activityReference): self
+    {
+        $this->activityReference = $activityReference;
+
+        return $this;
+    }
+
+    public function getDate(): ?\DateTimeInterface
+    {
+        return $this->date;
+    }
+
+    public function setDate(?\DateTimeInterface $date): self
+    {
+        $this->date = $date;
+
+        return $this;
+    }
+
+    public function getGroups(): ?int
+    {
+        return $this->groups;
+    }
+
+    public function setGroups(?int $groups): self
+    {
+        $this->groups = $groups;
+
+        return $this;
+    }
+
+    public function getLevels(): ?string
+    {
+        return $this->levels;
+    }
+
+    public function setLevels(?string $levels): self
+    {
+        $this->levels = $levels;
+
+        return $this;
+    }
+
+    public function getThemes(): ?string
+    {
+        return $this->themes;
+    }
+
+    public function setThemes(?string $themes): self
+    {
+        $this->themes = $themes;
+
+        return $this;
+    }
+
+    public function getContent(): ?string
+    {
+        return $this->content;
+    }
+
+    public function setContent(?string $content): self
+    {
+        $this->content = $content;
+
+        return $this;
+    }
+
+    /**
+     * @return Collection<int, Tool>
+     */
+    public function getTools(): Collection
+    {
+        return $this->tools;
+    }
+
+    public function addTool(Tool $tool): self
+    {
+        if (!$this->tools->contains($tool)) {
+            $this->tools[] = $tool;
+        }
+
+        return $this;
+    }
+
+    public function removeTool(Tool $tool): self
+    {
+        $this->tools->removeElement($tool);
+
+        return $this;
+    }
+
+    public function getToolsDetails(): ?string
+    {
+        return $this->toolsDetails;
+    }
+
+    public function setToolsDetails(?string $toolsDetails): self
+    {
+        $this->toolsDetails = $toolsDetails;
+
+        return $this;
+    }
+
+    public function getFeedback(): ?string
+    {
+        return $this->feedback;
+    }
+
+    public function setFeedback(?string $feedback): self
+    {
+        $this->feedback = $feedback;
+
+        return $this;
+    }
+
+    public function getVigilantPoints(): ?string
+    {
+        return $this->vigilantPoints;
+    }
+
+    public function setVigilantPoints(?string $vigilantPoints): self
+    {
+        $this->vigilantPoints = $vigilantPoints;
+
+        return $this;
+    }
+}

src/Entity/Speaker.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Entity;
+
+use App\Core\Entity\EntityInterface;
+use App\Repository\SpeakerRepository;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity(repositoryClass=SpeakerRepository::class)
+ */
+class Speaker implements EntityInterface
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     */
+    private $id;
+
+    /**
+     * @ORM\Column(type="string", length=255)
+     */
+    private $name;
+
+    /**
+     * @ORM\ManyToMany(targetEntity=Intervention::class, mappedBy="speaker")
+     */
+    private $interventions;
+
+    public function __construct()
+    {
+        $this->interventions = new ArrayCollection();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getName(): ?string
+    {
+        return $this->name;
+    }
+
+    public function setName(string $name): self
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * @return Collection<int, Intervention>
+     */
+    public function getInterventions(): Collection
+    {
+        return $this->interventions;
+    }
+
+    public function addIntervention(Intervention $intervention): self
+    {
+        if (!$this->interventions->contains($intervention)) {
+            $this->interventions[] = $intervention;
+            $intervention->addSpeaker($this);
+        }
+
+        return $this;
+    }
+
+    public function removeIntervention(Intervention $intervention): self
+    {
+        if ($this->interventions->removeElement($intervention)) {
+            $intervention->removeSpeaker($this);
+        }
+
+        return $this;
+    }
+}

src/Entity/Tool.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Entity;
+
+use App\Repository\ToolRepository;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use App\Core\Entity\EntityInterface;
+
+/**
+ * @ORM\Entity(repositoryClass=ToolRepository::class)
+ */
+class Tool implements EntityInterface
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     */
+    private $id;
+
+    /**
+     * @ORM\Column(type="string", length=255)
+     */
+    private $label;
+
+    /**
+     * @ORM\ManyToMany(targetEntity=Intervention::class, mappedBy="tools")
+     */
+    private $interventions;
+
+    public function __construct()
+    {
+        $this->interventions = new ArrayCollection();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getLabel(): ?string
+    {
+        return $this->label;
+    }
+
+    public function setLabel(string $label): self
+    {
+        $this->label = $label;
+
+        return $this;
+    }
+
+    /**
+     * @return Collection<int, Intervention>
+     */
+    public function getInterventions(): Collection
+    {
+        return $this->interventions;
+    }
+
+    public function addIntervention(Intervention $intervention): self
+    {
+        if (!$this->interventions->contains($intervention)) {
+            $this->interventions[] = $intervention;
+            $intervention->addTool($this);
+        }
+
+        return $this;
+    }
+
+    public function removeIntervention(Intervention $intervention): self
+    {
+        if ($this->interventions->removeElement($intervention)) {
+            $intervention->removeTool($this);
+        }
+
+        return $this;
+    }
+}

src/Factory/EstablishmentFactory.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Factory;
+
+use App\Core\Factory\FactoryInterface;
+use App\Entity\Establishment as Entity;
+
+class EstablishmentFactory implements FactoryInterface
+{
+    public function create(): Entity
+    {
+        return new Entity();
+    }
+}

src/Factory/InterventionFactory.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Factory;
+
+use App\Core\Factory\FactoryInterface;
+use App\Entity\Intervention as Entity;
+
+class InterventionFactory implements FactoryInterface
+{
+    public function create(): Entity
+    {
+        return new Entity();
+    }
+}

src/Factory/SpeakerFactory.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Factory;
+
+use App\Core\Factory\FactoryInterface;
+use App\Entity\Speaker as Entity;
+
+class SpeakerFactory implements FactoryInterface
+{
+    public function create(): Entity
+    {
+        return new Entity();
+    }
+}

src/Factory/ToolFactory.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Factory;
+
+use App\Core\Factory\FactoryInterface;
+use App\Entity\Tool as Entity;
+
+class ToolFactory implements FactoryInterface
+{
+    public function create(): Entity
+    {
+        return new Entity();
+    }
+}

src/Form/EstablishmentType.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Form;
+
+use App\Entity\Establishment;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class EstablishmentType extends AbstractType
+{
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $builder
+            ->add('name')
+            ->add('address')
+            ->add('zipCode')
+            ->add('city')
+        ;
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        $resolver->setDefaults([
+            'data_class' => Establishment::class,
+        ]);
+    }
+}

src/Form/InterventionType.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Form;
+
+use App\Entity\Intervention;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class InterventionType extends AbstractType
+{
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $builder
+            ->add('activityReference')
+            ->add('date')
+            ->add('groups')
+            ->add('levels')
+            ->add('themes')
+            ->add('content')
+            ->add('toolsDetails')
+            ->add('feedback')
+            ->add('vigilantPoints')
+            ->add('speaker')
+            ->add('establishment')
+            ->add('tools')
+        ;
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        $resolver->setDefaults([
+            'data_class' => Intervention::class,
+        ]);
+    }
+}

src/Form/SpeakerType.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Form;
+
+use App\Entity\Speaker;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class SpeakerType extends AbstractType
+{
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $builder
+            ->add('name')
+        ;
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        $resolver->setDefaults([
+            'data_class' => Speaker::class,
+        ]);
+    }
+}

src/Form/ToolType.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Form;
+
+use App\Entity\Tool;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class ToolType extends AbstractType
+{
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $builder
+            ->add('label')
+        ;
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        $resolver->setDefaults([
+            'data_class' => Tool::class,
+        ]);
+    }
+}

src/Repository/EstablishmentRepository.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Repository;
+
+use App\Entity\Establishment;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\ORM\OptimisticLockException;
+use Doctrine\ORM\ORMException;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @method Establishment|null find($id, $lockMode = null, $lockVersion = null)
+ * @method Establishment|null findOneBy(array $criteria, array $orderBy = null)
+ * @method Establishment[]    findAll()
+ * @method Establishment[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class EstablishmentRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Establishment::class);
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function add(Establishment $entity, bool $flush = true): void
+    {
+        $this->_em->persist($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function remove(Establishment $entity, bool $flush = true): void
+    {
+        $this->_em->remove($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    // /**
+    //  * @return Establishment[] Returns an array of Establishment objects
+    //  */
+    /*
+    public function findByExampleField($value)
+    {
+        return $this->createQueryBuilder('e')
+            ->andWhere('e.exampleField = :val')
+            ->setParameter('val', $value)
+            ->orderBy('e.id', 'ASC')
+            ->setMaxResults(10)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+    */
+
+    /*
+    public function findOneBySomeField($value): ?Establishment
+    {
+        return $this->createQueryBuilder('e')
+            ->andWhere('e.exampleField = :val')
+            ->setParameter('val', $value)
+            ->getQuery()
+            ->getOneOrNullResult()
+        ;
+    }
+    */
+}

src/Repository/EstablishmentRepositoryQueryQuery.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Repository;
+
+use App\Core\Repository\RepositoryQuery;
+use Knp\Component\Pager\PaginatorInterface;
+use App\Repository\EstablishmentRepositoryQuery as Repository;
+
+class EstablishmentRepositoryQueryQuery extends RepositoryQuery
+{
+    public function __construct(Repository $repository, PaginatorInterface $paginator)
+    {
+        parent::__construct($repository, 'e', $paginator);
+    }
+}

src/Repository/InterventionRepository.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Repository;
+
+use App\Entity\Intervention;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\ORM\OptimisticLockException;
+use Doctrine\ORM\ORMException;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @method Intervention|null find($id, $lockMode = null, $lockVersion = null)
+ * @method Intervention|null findOneBy(array $criteria, array $orderBy = null)
+ * @method Intervention[]    findAll()
+ * @method Intervention[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class InterventionRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Intervention::class);
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function add(Intervention $entity, bool $flush = true): void
+    {
+        $this->_em->persist($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function remove(Intervention $entity, bool $flush = true): void
+    {
+        $this->_em->remove($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    // /**
+    //  * @return Intervention[] Returns an array of Intervention objects
+    //  */
+    /*
+    public function findByExampleField($value)
+    {
+        return $this->createQueryBuilder('i')
+            ->andWhere('i.exampleField = :val')
+            ->setParameter('val', $value)
+            ->orderBy('i.id', 'ASC')
+            ->setMaxResults(10)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+    */
+
+    /*
+    public function findOneBySomeField($value): ?Intervention
+    {
+        return $this->createQueryBuilder('i')
+            ->andWhere('i.exampleField = :val')
+            ->setParameter('val', $value)
+            ->getQuery()
+            ->getOneOrNullResult()
+        ;
+    }
+    */
+}

src/Repository/InterventionRepositoryQueryQuery.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Repository;
+
+use App\Core\Repository\RepositoryQuery;
+use Knp\Component\Pager\PaginatorInterface;
+use App\Repository\InterventionRepositoryQuery as Repository;
+
+class InterventionRepositoryQueryQuery extends RepositoryQuery
+{
+    public function __construct(Repository $repository, PaginatorInterface $paginator)
+    {
+        parent::__construct($repository, 'i', $paginator);
+    }
+}

src/Repository/SpeakerRepository.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Repository;
+
+use App\Entity\Speaker;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\ORM\OptimisticLockException;
+use Doctrine\ORM\ORMException;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @method Speaker|null find($id, $lockMode = null, $lockVersion = null)
+ * @method Speaker|null findOneBy(array $criteria, array $orderBy = null)
+ * @method Speaker[]    findAll()
+ * @method Speaker[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class SpeakerRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Speaker::class);
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function add(Speaker $entity, bool $flush = true): void
+    {
+        $this->_em->persist($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function remove(Speaker $entity, bool $flush = true): void
+    {
+        $this->_em->remove($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    // /**
+    //  * @return Speaker[] Returns an array of Speaker objects
+    //  */
+    /*
+    public function findByExampleField($value)
+    {
+        return $this->createQueryBuilder('s')
+            ->andWhere('s.exampleField = :val')
+            ->setParameter('val', $value)
+            ->orderBy('s.id', 'ASC')
+            ->setMaxResults(10)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+    */
+
+    /*
+    public function findOneBySomeField($value): ?Speaker
+    {
+        return $this->createQueryBuilder('s')
+            ->andWhere('s.exampleField = :val')
+            ->setParameter('val', $value)
+            ->getQuery()
+            ->getOneOrNullResult()
+        ;
+    }
+    */
+}

src/Repository/SpeakerRepositoryQueryQuery.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Repository;
+
+use App\Core\Repository\RepositoryQuery;
+use Knp\Component\Pager\PaginatorInterface;
+use App\Repository\SpeakerRepositoryQuery as Repository;
+
+class SpeakerRepositoryQueryQuery extends RepositoryQuery
+{
+    public function __construct(Repository $repository, PaginatorInterface $paginator)
+    {
+        parent::__construct($repository, 's', $paginator);
+    }
+}

src/Repository/ToolRepository.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Repository;
+
+use App\Entity\Tool;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\ORM\OptimisticLockException;
+use Doctrine\ORM\ORMException;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @method Tool|null find($id, $lockMode = null, $lockVersion = null)
+ * @method Tool|null findOneBy(array $criteria, array $orderBy = null)
+ * @method Tool[]    findAll()
+ * @method Tool[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class ToolRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Tool::class);
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function add(Tool $entity, bool $flush = true): void
+    {
+        $this->_em->persist($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    /**
+     * @throws ORMException
+     * @throws OptimisticLockException
+     */
+    public function remove(Tool $entity, bool $flush = true): void
+    {
+        $this->_em->remove($entity);
+        if ($flush) {
+            $this->_em->flush();
+        }
+    }
+
+    // /**
+    //  * @return Tool[] Returns an array of Tool objects
+    //  */
+    /*
+    public function findByExampleField($value)
+    {
+        return $this->createQueryBuilder('t')
+            ->andWhere('t.exampleField = :val')
+            ->setParameter('val', $value)
+            ->orderBy('t.id', 'ASC')
+            ->setMaxResults(10)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+    */
+
+    /*
+    public function findOneBySomeField($value): ?Tool
+    {
+        return $this->createQueryBuilder('t')
+            ->andWhere('t.exampleField = :val')
+            ->setParameter('val', $value)
+            ->getQuery()
+            ->getOneOrNullResult()
+        ;
+    }
+    */
+}

src/Repository/ToolRepositoryQueryQuery.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Repository;
+
+use App\Core\Repository\RepositoryQuery;
+use Knp\Component\Pager\PaginatorInterface;
+use App\Repository\ToolRepositoryQuery as Repository;
+
+class ToolRepositoryQueryQuery extends RepositoryQuery
+{
+    public function __construct(Repository $repository, PaginatorInterface $paginator)
+    {
+        parent::__construct($repository, 't', $paginator);
+    }
+}