interface

Doctrine/Extension/DescriptionProjectInterface.php

+<?php
+
+namespace Lc\PietroBundle\Doctrine\Extension;
+
+interface DescriptionProjectInterface
+{
+
+}

Doctrine/Extension/DescriptionProjectTrait.php

+<?php
+
+namespace Lc\PietroBundle\Doctrine\Extension;
+
+use Lc\PietroBundle\Model\ThematicInterface;
+use Lc\PietroBundle\Model\SubthematicInterface;
+use Doctrine\ORM\Mapping as ORM;
+
+trait DescriptionProjectTrait
+{
+
+    /**
+     * @ORM\Column(type="text")
+     */
+    private $description;
+
+    /**
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\ThematicInterface")
+     */
+    private $thematic;
+
+    /**
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\SubthematicInterface")
+     */
+    private $subthematic;
+
+    public function getDescription(): ?string
+    {
+        return $this->description;
+    }
+
+    public function setDescription(string $description): self
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    public function getThematic(): ?ThematicInterface
+    {
+        return $this->thematic;
+    }
+
+    public function setThematic(?ThematicInterface $thematic): self
+    {
+        $this->thematic = $thematic;
+
+        return $this;
+    }
+
+    public function getSubthematic(): ?SubthematicInterface
+    {
+        return $this->subthematic;
+    }
+
+    public function setSubthematic(?SubthematicInterface $subthematic): self
+    {
+        $this->subthematic = $subthematic;
+
+        return $this;
+    }
+
+}

Form/Dream/DreamType.php

 
 namespace Lc\PietroBundle\Form\Dream;
 
-use Lc\PietroBundle\Model\Dream;
+use Lc\PietroBundle\Model\DreamModel;
 use Lc\PietroBundle\Model\Subthematic;
 use Lc\PietroBundle\Model\Thematic;
 use Lc\SovBundle\Doctrine\EntityManager;
     {
         $resolver->setDefaults(
             [
-                'data_class' => $this->em->getEntityName(Dream::class),
+                'data_class' => $this->em->getEntityName(DreamModel::class),
                 'context' => 'backend'
             ]
         );

Model/Dream.php

-<?php
-
-namespace Lc\PietroBundle\Model;
-
-use Doctrine\ORM\Mapping as ORM;
-use App\Doctrine\Extension\DescriptionProjectInterface;
-use App\Doctrine\Extension\DescriptionProjectTrait;
-use Lc\SovBundle\Doctrine\EntityInterface;
-
-/**
- * @ORM\MappedSuperclass()
- */
-abstract class Dream implements DescriptionProjectInterface, EntityInterface
-{
-    use DescriptionProjectTrait;
-
-    /**
-     * @ORM\ManyToOne(targetEntity=IndividualData::class, inversedBy="dream")
-     */
-    private $individualData;
-
-
-    public function __toString()
-    {
-        return "Nos rêves";
-    }
-
-    public function getIndividualData(): ?IndividualData
-    {
-        return $this->individualData;
-    }
-
-    public function setIndividualData(?IndividualData $individualData): self
-    {
-        $this->individualData = $individualData;
-
-        return $this;
-    }
-
-}

Model/DreamInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface DreamInterface
+{
+
+}

Model/DreamModel.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+use Doctrine\ORM\Mapping as ORM;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectTrait;
+
+/**
+ * @ORM\MappedSuperclass()
+ */
+abstract class DreamModel implements DescriptionProjectInterface, DreamInterface
+{
+    use DescriptionProjectTrait;
+
+    /**
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\IndividualDataInterface", inversedBy="dream")
+     */
+    private $individualData;
+
+
+    public function __toString()
+    {
+        return "Nos rêves";
+    }
+
+    public function getIndividualData(): ?IndividualDataInterface
+    {
+        return $this->individualData;
+    }
+
+    public function setIndividualData(?IndividualDataInterface $individualData): self
+    {
+        $this->individualData = $individualData;
+
+        return $this;
+    }
+
+}

Model/IndividualData.php

 /**
  * @ORM\MappedSuperclass()
  */
-abstract class IndividualData extends AbstractData
+abstract class IndividualData extends AbstractData implements IndividualDataInterface
 {
 
     /**
     private $introAnswer;
 
     /**
-     * @ORM\OneToMany(targetEntity=Revolt::class, mappedBy="individualData", cascade={"persist", "remove"})
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\RevoltInterface", mappedBy="individualData", cascade={"persist", "remove"})
      */
     protected $revolt;
 
     /**
-     * @ORM\OneToMany(targetEntity=Dream::class, mappedBy="individualData", cascade={"persist", "remove"})
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\DreamInterface", mappedBy="individualData", cascade={"persist", "remove"})
      */
     protected $dream;
 
     /**
-     * @ORM\OneToMany(targetEntity=ProjectBoost::class, mappedBy="individualData", cascade={"persist", "remove"})
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\ProjectBoostInterface", mappedBy="individualData", cascade={"persist", "remove"})
      */
     protected $projectBoost;
 
     /**
-     * @ORM\OneToMany(targetEntity=ProjectInspiring::class, mappedBy="individualData", cascade={"persist", "remove"})
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\ProjectInspiringInterface", mappedBy="individualData", cascade={"persist", "remove"})
      */
     protected $projectInspiring;
 
     /**
-     * @ORM\ManyToOne(targetEntity=Territory::class, inversedBy="individualData")
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\TerritoryInterface", inversedBy="individualData")
      */
     protected $territory;
 
     }
 
     /**
-     * @return Collection|Revolt[]
+     * @return Collection|RevoltInterface[]
      */
     public function getRevolt(): Collection
     {
         return $this->revolt;
     }
 
-    public function addRevolt(Revolt $revolt): self
+    public function addRevolt(RevoltInterface $revolt): self
     {
         if (!$this->revolt->contains($revolt)) {
             $this->revolt[] = $revolt;
         return $this;
     }
 
-    public function removeRevolt(Revolt $revolt): self
+    public function removeRevolt(RevoltInterface $revolt): self
     {
         if ($this->revolt->removeElement($revolt)) {
             // set the owning side to null (unless already changed)
     }
 
     /**
-     * @return Collection|Dream[]
+     * @return Collection|DreamInterface[]
      */
     public function getDream(): Collection
     {
         return $this->dream;
     }
 
-    public function addDream(Dream $dream): self
+    public function addDream(DreamInterface $dream): self
     {
         if (!$this->dream->contains($dream)) {
             $this->dream[] = $dream;
         return $this;
     }
 
-    public function removeDream(Dream $dream): self
+    public function removeDream(DreamInterface $dream): self
     {
         if ($this->dream->removeElement($dream)) {
             // set the owning side to null (unless already changed)
     }
 
     /**
-     * @return Collection|ProjectBoost[]
+     * @return Collection|ProjectBoostInterface[]
      */
     public function getProjectBoost(): Collection
     {
         return $this->projectBoost;
     }
 
-    public function addProjectBoost(ProjectBoost $projectBoost): self
+    public function addProjectBoost(ProjectBoostInterface $projectBoost): self
     {
         if (!$this->projectBoost->contains($projectBoost)) {
             $this->projectBoost[] = $projectBoost;
         return $this;
     }
 
-    public function removeProjectBoost(ProjectBoost $projectBoost): self
+    public function removeProjectBoost(ProjectBoostInterface $projectBoost): self
     {
         if ($this->projectBoost->removeElement($projectBoost)) {
             // set the owning side to null (unless already changed)
     }
 
     /**
-     * @return Collection|ProjectInspiring[]
+     * @return Collection|ProjectInspiringInterface[]
      */
     public function getProjectInspiring(): Collection
     {
         return $this->projectInspiring;
     }
 
-    public function addProjectInspiring(ProjectInspiring $projectInspiring): self
+    public function addProjectInspiring(ProjectInspiringInterface $projectInspiring): self
     {
         if (!$this->projectInspiring->contains($projectInspiring)) {
             $this->projectInspiring[] = $projectInspiring;
         return $this;
     }
 
-    public function removeProjectInspiring(ProjectInspiring $projectInspiring): self
+    public function removeProjectInspiring(ProjectInspiringInterface $projectInspiring): self
     {
         if ($this->projectInspiring->removeElement($projectInspiring)) {
             // set the owning side to null (unless already changed)
         return $this;
     }
 
-    public function getTerritory(): ?Territory
+    public function getTerritory(): ?TerritoryInterface
     {
         return $this->territory;
     }
 
-    public function setTerritory(?Territory $territory): self
+    public function setTerritory(?TerritoryInterface $territory): self
     {
         $this->territory = $territory;
 

Model/IndividualDataInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface IndividualDataInterface
+{
+
+}

Model/ProjectBoost.php

 
 namespace Lc\PietroBundle\Model;
 
-use App\Repository\ProjectBoostRepository;
 use Doctrine\ORM\Mapping as ORM;
-use App\Doctrine\Extension\DescriptionProjectInterface;
-use App\Doctrine\Extension\DescriptionProjectTrait;
-use Lc\SovBundle\Doctrine\EntityInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectTrait;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ProjectBoost implements DescriptionProjectInterface, EntityInterface
+abstract class ProjectBoost implements DescriptionProjectInterface, ProjectBoostInterface
 {
     use DescriptionProjectTrait;
 
     /**
-     * @ORM\ManyToOne(targetEntity=IndividualData::class, inversedBy="projectBoost")
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\IndividualDataInterface", inversedBy="projectBoost")
      */
     private $individualData;
 

Model/ProjectBoostInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface ProjectBoostInterface
+{
+
+}

Model/ProjectInspiring.php

 
 namespace Lc\PietroBundle\Model;
 
-use App\Repository\ProjectInspiringRepository;
 use Doctrine\ORM\Mapping as ORM;
-use App\Doctrine\Extension\DescriptionProjectInterface;
-use App\Doctrine\Extension\DescriptionProjectTrait;
-use Lc\SovBundle\Doctrine\EntityInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectTrait;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ProjectInspiring implements DescriptionProjectInterface, EntityInterface
+abstract class ProjectInspiring implements DescriptionProjectInterface, ProjectInspiringInterface
 {
     use DescriptionProjectTrait;
 
     /**
-     * @ORM\ManyToOne(targetEntity=IndividualData::class, inversedBy="projectInspiring")
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\IndividualDataInterface", inversedBy="projectInspiring")
      */
     private $individualData;
 
         return "Les actions inspirantes";
     }
 
-    public function getIndividualData(): ?IndividualData
+    public function getIndividualData(): ?IndividualDataInterface
     {
         return $this->individualData;
     }
 
-    public function setIndividualData(?IndividualData $individualData): self
+    public function setIndividualData(?IndividualDataInterface $individualData): self
     {
         $this->individualData = $individualData;
 

Model/ProjectInspiringInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface ProjectInspiringInterface
+{
+
+}

Model/Revolt.php

 namespace Lc\PietroBundle\Model;
 
 use Doctrine\ORM\Mapping as ORM;
-use App\Doctrine\Extension\DescriptionProjectInterface;
-use App\Doctrine\Extension\DescriptionProjectTrait;
-use Lc\SovBundle\Doctrine\EntityInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectInterface;
+use Lc\PietroBundle\Doctrine\Extension\DescriptionProjectTrait;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Revolt implements DescriptionProjectInterface, EntityInterface
+abstract class Revolt implements DescriptionProjectInterface, RevoltInterface
 {
     use DescriptionProjectTrait;
 
     /**
-     * @ORM\ManyToOne(targetEntity=IndividualData::class, inversedBy="revolt")
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\IndividualDataInterface", inversedBy="revolt")
      */
     private $individualData;
 
         return "Nos révoltes";
     }
 
-    public function getIndividualData(): ?IndividualData
+    public function getIndividualData(): ?IndividualDataInterface
     {
         return $this->individualData;
     }
 
-    public function setIndividualData(?IndividualData $individualData): self
+    public function setIndividualData(?IndividualDataInterface $individualData): self
     {
         $this->individualData = $individualData;
 

Model/RevoltInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface RevoltInterface
+{
+
+}

Model/Subthematic.php

 namespace Lc\PietroBundle\Model;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\SovBundle\Doctrine\EntityInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Subthematic implements EntityInterface
+abstract class Subthematic implements SubthematicInterface
 {
     /**
      * @ORM\Column(type="string", length=255)
     private $name;
 
     /**
-     * @ORM\ManyToOne(targetEntity=Thematic::class, inversedBy="subthematic")
+     * @ORM\ManyToOne(targetEntity="Lc\PietroBundle\Model\ThematicInterface", inversedBy="subthematic")
      */
     private $thematic;
 
         return $this;
     }
 
-    public function getThematic(): ?Thematic
+    public function getThematic(): ?ThematicInterface
     {
         return $this->thematic;
     }
 
-    public function setThematic(?Thematic $thematic): self
+    public function setThematic(?ThematicInterface $thematic): self
     {
         $this->thematic = $thematic;
 

Model/SubthematicInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface SubthematicInterface
+{
+
+}

Model/Territory.php

 
 namespace Lc\PietroBundle\Model;
 
-use App\Repository\TerritoryRepository;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\SovBundle\Doctrine\EntityInterface;
 use Lc\SovBundle\Doctrine\Extension\DevAliasInterface;
 use Lc\SovBundle\Doctrine\Extension\DevAliasTrait;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Territory implements EntityInterface, DevAliasInterface
+abstract class Territory implements TerritoryInterface, DevAliasInterface
 {
     use DevAliasTrait;
 
     private $name;
 
     /**
-     * @ORM\OneToMany(targetEntity=IndividualData::class, mappedBy="territory")
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\IndividualDataInterface", mappedBy="territory")
      */
     private $individualData;
 
         return $this->individualData;
     }
 
-    public function setIndividualData(?IndividualData $individualData): self
+    public function setIndividualData(?IndividualDataInterface $individualData): self
     {
         $this->individualData = $individualData;
 
     }
 
     /**
-     * @return Collection|Territory[]
+     * @return Collection|TerritoryInterface[]
      */
     public function getTerritory(): Collection
     {
         return $this->territory;
     }
 
-    public function addTerritory(Territory $territory): self
+    public function addTerritory(TerritoryInterface $territory): self
     {
         if (!$this->territory->contains($territory)) {
             $this->territory[] = $territory;
         return $this;
     }
 
-    public function removeTerritory(Territory $territory): self
+    public function removeTerritory(TerritoryInterface $territory): self
     {
         if ($this->territory->removeElement($territory)) {
             // set the owning side to null (unless already changed)

Model/TerritoryInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface TerritoryInterface
+{
+
+}

Model/Thematic.php

 
 namespace Lc\PietroBundle\Model;
 
-use App\Repository\ThematicRepository;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\SovBundle\Doctrine\EntityInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Thematic implements EntityInterface
+abstract class Thematic implements ThematicInterface
 {
 
     /**
     private $name;
 
     /**
-     * @ORM\OneToMany(targetEntity=Subthematic::class, mappedBy="thematic", cascade={"persist", "remove"})
+     * @ORM\OneToMany(targetEntity="Lc\PietroBundle\Model\SubthematicInterface", mappedBy="thematic", cascade={"persist", "remove"})
      */
     private $subthematic;
 
     }
 
     /**
-     * @return Collection|Subthematic[]
+     * @return Collection|SubthematicInterface[]
      */
     public function getSubthematic(): Collection
     {
         return $this->subthematic;
     }
 
-    public function addSubthematic(Subthematic $subthematic): self
+    public function addSubthematic(SubthematicInterface $subthematic): self
     {
         if (!$this->subthematic->contains($subthematic)) {
             $this->subthematic[] = $subthematic;
         return $this;
     }
 
-    public function removeSubthematic(Subthematic $subthematic): self
+    public function removeSubthematic(SubthematicInterface $subthematic): self
     {
         if ($this->subthematic->removeElement($subthematic)) {
             // set the owning side to null (unless already changed)

Model/ThematicInterface.php

+<?php
+
+namespace Lc\PietroBundle\Model;
+
+interface ThematicInterface
+{
+
+}

Repository/Dream/DreamRepository.php

 
 namespace Lc\PietroBundle\Repository\Dream;
 
-use Lc\PietroBundle\Model\Dream;
+use Lc\PietroBundle\Model\DreamModel;
 use Lc\SovBundle\Repository\AbstractRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
 {
     public function __construct(ManagerRegistry $registry)
     {
-        parent::__construct($registry, Dream::class);
+        parent::__construct($registry, DreamModel::class);
     }
 }

Repository/Dream/DreamRepositoryQuery.php

 use Knp\Component\Pager\PaginatorInterface;
 use Lc\PietroBundle\Repository\Search\SearchRepositoryQuery;
 
-class DreamRepositoryQuery extends SearchRepositoryQuery
+class DreamRepositoryQuery extends SearchRepositoryQuery implements DreamRepositoryQueryInterface
 {
     public function __construct(DreamRepository $repository, PaginatorInterface $paginator)
     {

Repository/Dream/DreamRepositoryQueryInterface.php

+<?php
+
+namespace Lc\PietroBundle\Repository\Dream;
+
+interface DreamRepositoryQueryInterface
+{
+
+}

Repository/Dream/DreamStore.php

 namespace Lc\PietroBundle\Repository\Dream;
 
 use Lc\PietroBundle\Repository\Search\SearchStore;
+use Lc\SovBundle\Repository\RepositoryQueryInterface;
 
-class DreamStore extends SearchStore
+class DreamStore extends SearchStore implements DreamStoreInterface
 {
     protected $query;
 
-    public function __construct(DreamRepositoryQuery $query)
+    public function __construct(DreamRepositoryQueryInterface $query)
     {
         $this->query = $query;
     }
+
+    public function orderByDefault(RepositoryQueryInterface $query): RepositoryQueryInterface
+    {
+        return $query;
+    }
+
+    public function filtersDefault(RepositoryQueryInterface $query): RepositoryQueryInterface
+    {
+        return $query;
+    }
+
+    public function relationsDefault(RepositoryQueryInterface $query): RepositoryQueryInterface
+    {
+        return $query;
+    }
 }

Repository/Dream/DreamStoreInterface.php

+<?php
+
+namespace Lc\PietroBundle\Repository\Dream;
+
+interface DreamStoreInterface
+{
+
+}