src/Entity/Categorie.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CategorieRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass:CategorieRepository ::class)]
  12. class Categorie
  13. {
  14.     //Déclarations des variables
  15.     #[ORM\Id]
  16.     #[ORM\Column(name: 'id_categorie',type: 'integer',nullable: false)]
  17.     #[ORM\GeneratedValue(strategy:'IDENTITY')]
  18.     private ?int $id;
  20.     #[ORM\Column(length: 255, nullable: false)]
  21.     private ?string $nom = null;
  23.     //Associations
  24.     #[ORM\OneToMany(mappedBy:'categorie', targetEntity: SousCategorie::class)]
  25.     private Collection $sousCategories;
  27.     //Association bidirectionnelle
  28.     #[ORM\ManyToMany(targetEntity: Model::class, mappedBy:'categories')]
  29.     private ?Collection $models;
  31.     #[ORM\ManyToMany(targetEntity: TypeCollection::class, mappedBy: 'categories')]
  32.     private Collection $typeCollections;
  35.     //Constructeur
  36.     public function __construct()
  37.     {
  38.         $this->sousCategories = new ArrayCollection();
  39.         $this->models = new ArrayCollection();
  40.         $this->typeCollections = new ArrayCollection();
  41.     }
  43.     //Getters et Setters
  44.     /**
  45.      * @return int|null
  46.      */
  47.     public function getId(): ?int
  48.     {
  49.         return $this->id;
  50.     }
  52.     /**
  53.      * @return string|null
  54.      */
  55.     public function getNom(): ?string
  56.     {
  57.         return $this->nom;
  58.     }
  60.     /**
  61.      * @param string|null $nom
  62.      */
  63.     public function setNom(?string $nom): void
  64.     {
  65.         $this->nom = $nom;
  66.     }
  68.     /**
  69.      * @return Collection<int, SousCategorie>
  70.      */
  71.     public function getSousCategories(): Collection
  72.     {
  73.         return $this->sousCategories;
  74.     }
  76.     public function addSousCategorie(SousCategorie $sousCategorie): self
  77.     {
  78.         if (!$this->sousCategories->contains($sousCategorie)) {
  79.             $this->sousCategories->add($sousCategorie);
  80.             $sousCategorie->addCategorie($this);
  81.         }
  83.         return $this;
  84.     }
  86.     public function removeSousCategorie(SousCategorie $sousCategorie): self
  87.     {
  88.         if ($this->sousCategories->removeElement($sousCategorie)) {
  89.             // set the owning side to null (unless already changed)
  90.             if ($sousCategorie->getCategorie() === $this) {
  91.                 $sousCategorie->removeCategorie(null);
  92.             }
  93.         }
  95.         return $this;
  96.     }
  98.     /**
  99.      * @return Collection<int, Model>
  100.      */
  101.     public function getModels(): Collection
  102.     {
  103.         return $this->models;
  104.     }
  106.     public function addModel(Model $model): self
  107.     {
  108.         if (!$this->models->contains($model)) {
  109.             $this->models->add($model);
  110.             $model->addCategorie($this);
  111.         }
  113.         return $this;
  114.     }
  116.     public function removeModel(Model $model): self
  117.     {
  118.         if ($this->models->removeElement($model)) {
  119.             // set the owning side to null (unless already changed)
  120.             if ($model->getCategories() === $this) {
  121.                 $model->addCategorie(null);
  122.             }
  123.         }
  125.         return $this;
  126.     }
  128.     public function __toString(): string
  129.     {
  130.         return $this->nom ?? '';
  131.     }
  133.     /**
  134.      * @return Collection<int, TypeCollection>
  135.      */
  136.     public function getTypeCollections(): Collection
  137.     {
  138.         return $this->typeCollections;
  139.     }
  141.     public function addTypeCollection(TypeCollection $typeCollection): self
  142.     {
  143.         if (!$this->typeCollections->contains($typeCollection)) {
  144.             $this->typeCollections->add($typeCollection);
  145.             $typeCollection->addCategory($this);
  146.         }
  148.         return $this;
  149.     }
  151.     public function removeTypeCollection(TypeCollection $typeCollection): self
  152.     {
  153.         if ($this->typeCollections->removeElement($typeCollection)) {
  154.             $typeCollection->removeCategory($this);
  155.         }
  157.         return $this;
  158.     }
  160. }