src/Entity/Categories.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Trait\CodeTrait;
  6. use App\Entity\Trait\SlugTrait;
  7. use App\Repository\CategoriesRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  12. #[ORM\Entity(repositoryClass: CategoriesRepository::class)]
  13. class Categories
  14. {
  15.     use CodeTrait ;
  16.     use SlugTrait ;
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column()]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $libelle = null;
  25.     #[ORM\Column(length: 255, nullable: true)]
  26.     private ?string $description = null;
  28.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
  29.     #[ORM\JoinColumn(nullable: true)]
  30.     private ?self $parent = null;
  32.     #[ORM\OneToMany(mappedBy: 'categorie', targetEntity: Articles::class)]
  33.     private Collection $articles;
  35.     #[ORM\Column(nullable: true)]
  36.     private ?bool $isActif = null;
  38.     private ?string $fullLibelle;
  40.     #[ORM\OneToMany(mappedBy: 'Categorie', targetEntity: Variables::class)]
  41.     private Collection $variables;
  43.     #[ORM\OneToMany(mappedBy: 'categorie', targetEntity: Immeubles::class)]
  44.     private Collection $immeubles;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $icon = null;
  49.     #[ORM\OneToMany(mappedBy: 'categorie', targetEntity: Services::class)]
  50.     private Collection $services;
  52.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  53.     private Collection $children;
  55.     public function __construct()
  56.     {
  57.         $this->children = new ArrayCollection();
  58.         $this->status = new ArrayCollection();
  59.         $this->variables = new ArrayCollection();
  60.         $this->immeubles = new ArrayCollection();
  61.         $this->services = new ArrayCollection();
  62.         $this->articles = new ArrayCollection();
  63.     }
  64.     public  function __toString(): string
  65.     {
  66.         return $this->getLibelle() ;
  67.     }
  69.     /**
  70.      * @return string|null
  71.      */
  72.     public function getFullLibelle(): ?string
  73.     {
  75.         return $this->fullLibelle;
  77.     }
  79.     /**
  80.      * @param string|null $fullLibelle
  81.      */
  82.     public function setFullLibelle(?string $fullLibelle): self
  83.     {
  84.         $this->fullLibelle = $fullLibelle;
  85.         return $this;
  86.     }
  89.     public function getId(): ?int
  90.     {
  91.         return $this->id;
  92.     }
  94.     public function getLibelle(): ?string
  95.     {
  96.         return $this->libelle;
  97.     }
  99.     public function setLibelle(string $libelle): self
  100.     {
  101.         $this->libelle = $libelle;
  103.         return $this;
  104.     }
  106.     public function getDescription(): ?string
  107.     {
  108.         return $this->description;
  109.     }
  111.     public function setDescription(?string $description): self
  112.     {
  113.         $this->description = $description;
  115.         return $this;
  116.     }
  118.     public function getParent(): ?self
  119.     {
  120.         return $this->parent;
  121.     }
  123.     public function setParent(?self $parent): self
  124.     {
  125.         $this->parent = $parent;
  127.         return $this;
  128.     }
  130.     public function addParent(self $parent): self
  131.     {
  132.         if (!$this->parent->contains($parent)) {
  133.             $this->parent[] = $parent;
  134.             $parent->setParent($this);
  135.         }
  137.         return $this;
  138.     }
  140.     public function removeParent(self $parent): self
  141.     {
  142.         if ($this->parent->removeElement($parent)) {
  143.             // set the owning side to null (unless already changed)
  144.             if ($parent->getParent() === $this) {
  145.                 $parent->setParent(null);
  146.             }
  147.         }
  149.         return $this;
  150.     }
  152.     /**
  153.      * @return Collection<int, Articles>
  154.      */
  155.     public function getArticles(): Collection
  156.     {
  157.         return $this->articles;
  158.     }
  160.     public function addArticles(Articles $articles): self
  161.     {
  162.         if (!$this->articles->contains($articles)) {
  163.             $this->articles[] = $articles;
  164.             $articles->setCategorie($this);
  165.         }
  167.         return $this;
  168.     }
  170.     public function removeStatus(Articles $articles): self
  171.     {
  172.         if ($this->articles->removeElement($articles)) {
  173.             // set the owning side to null (unless already changed)
  174.             if ($articles->getCategorie() === $this) {
  175.                 $articles->setCategorie(null);
  176.             }
  177.         }
  179.         return $this;
  180.     }
  182.     public function isIsActif(): ?bool
  183.     {
  184.         return $this->isActif;
  185.     }
  187.     public function setIsActif(?bool $isActif): self
  188.     {
  189.         $this->isActif = $isActif;
  191.         return $this;
  192.     }
  194.     /**
  195.      * @return Collection<int, Variables>
  196.      */
  197.     public function getVariables(): Collection
  198.     {
  199.         return $this->variables;
  200.     }
  202.     public function addVariable(Variables $variable): self
  203.     {
  204.         if (!$this->variables->contains($variable)) {
  205.             $this->variables[] = $variable;
  206.             $variable->setCategorie($this);
  207.         }
  209.         return $this;
  210.     }
  212.     public function removeVariable(Variables $variable): self
  213.     {
  214.         if ($this->variables->removeElement($variable)) {
  215.             // set the owning side to null (unless already changed)
  216.             if ($variable->getCategorie() === $this) {
  217.                 $variable->setCategorie(null);
  218.             }
  219.         }
  221.         return $this;
  222.     }
  224.     /**
  225.      * @return Collection<int, Immeubles>
  226.      */
  227.     public function getImmeubles(): Collection
  228.     {
  229.         return $this->immeubles;
  230.     }
  232.     public function addImmeuble(Immeubles $immeuble): self
  233.     {
  234.         if (!$this->immeubles->contains($immeuble)) {
  235.             $this->immeubles[] = $immeuble;
  236.             $immeuble->setCategorie($this);
  237.         }
  239.         return $this;
  240.     }
  242.     public function removeImmeuble(Immeubles $immeuble): self
  243.     {
  244.         if ($this->immeubles->removeElement($immeuble)) {
  245.             // set the owning side to null (unless already changed)
  246.             if ($immeuble->getCategorie() === $this) {
  247.                 $immeuble->setCategorie(null);
  248.             }
  249.         }
  251.         return $this;
  252.     }
  254.     public function getIcon(): ?string
  255.     {
  256.         return $this->icon;
  257.     }
  259.     public function setIcon(?string $icon): self
  260.     {
  261.         $this->icon = $icon;
  263.         return $this;
  264.     }
  266.     /**
  267.      * @return Collection<int, Services>
  268.      */
  269.     public function getServices(): Collection
  270.     {
  271.         return $this->services;
  272.     }
  274.     public function addService(Services $service): static
  275.     {
  276.         if (!$this->services->contains($service)) {
  277.             $this->services->add($service);
  278.             $service->setCategorie($this);
  279.         }
  281.         return $this;
  282.     }
  284.     public function removeService(Services $service): static
  285.     {
  286.         if ($this->services->removeElement($service)) {
  287.             // set the owning side to null (unless already changed)
  288.             if ($service->getCategorie() === $this) {
  289.                 $service->setCategorie(null);
  290.             }
  291.         }
  293.         return $this;
  294.     }
  295.     /**
  296.      * @return Collection<int, self>
  297.      */
  298.     public function getChildren(): Collection
  299.     {
  300.         return $this->children;
  301.     }
  303.     public function addChild(self $child): self
  304.     {
  305.         if (!$this->children->contains($child)) {
  306.             $this->children->add($child);
  307.             $child->setParent($this);
  308.         }
  310.         return $this;
  311.     }
  313.     public function removeChild(self $child): self
  314.     {
  315.         if ($this->children->removeElement($child)) {
  316.             if ($child->getParent() === $this) {
  317.                 $child->setParent(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324. }