src/Entity/Section.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SectionRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: SectionRepository::class)]
  12. class Section
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  21.     #[ORM\Column(length: 255)]
  22.     private ?string $titre = null;
  26.     #[ORM\Column]
  27.     private ?int $ordre = null;
  29.     #[ORM\Column]
  30.     private ?bool $actif = true;
  32.     #[ORM\OneToMany(mappedBy: 'section', targetEntity: Rubrique::class, cascade: ['remove', 'persist'])]
  33.     private Collection $rubriques;
  38.     #[ORM\ManyToOne(inversedBy: 'sections')]
  39.     private ?Document $document = null;
  41.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'subSections')]
  42.     private ?self $parentSection = null;
  44.     #[ORM\OneToMany(mappedBy: 'parentSection', targetEntity: self::class, cascade: ['remove', 'persist'])]
  45.     private Collection $subSections;
  47.     #[ORM\OneToMany(mappedBy: 'section', targetEntity: Element::class)]
  48.     private Collection $elements;
  50.     #[ORM\OneToMany(mappedBy: 'section', targetEntity: Bloc::class, cascade: ['remove', 'persist'] )]
  51.     private Collection $bloc;
  55.     public function __construct()
  56.     {
  57.         $this->rubriques = new ArrayCollection();
  58.         $this->subSections = new ArrayCollection();
  59.         $this->elements = new ArrayCollection();
  60.         $this->bloc = new ArrayCollection();
  62.     }
  64.     public function getId(): ?int
  65.     {
  66.         return $this->id;
  67.     }
  71.     public function getTitre(): ?string
  72.     {
  73.         return $this->titre;
  74.     }
  76.     public function setTitre(string $titre): static
  77.     {
  78.         $this->titre = $titre;
  80.         return $this;
  81.     }
  85.     public function getOrdre(): ?int
  86.     {
  87.         return $this->ordre;
  88.     }
  90.     public function setOrdre(int $ordre): static
  91.     {
  92.         $this->ordre = $ordre;
  94.         return $this;
  95.     }
  97.     public function isActif(): ?bool
  98.     {
  99.         return $this->actif;
  100.     }
  102.     public function setActif(bool $actif): static
  103.     {
  104.         $this->actif = $actif;
  106.         return $this;
  107.     }
  109.     /**
  110.      * @return Collection<int, Rubrique>
  111.      */
  112.     public function getRubriques(): Collection
  113.     {
  114.         return $this->rubriques;
  115.     }
  117.     public function addRubrique(Rubrique $rubrique): static
  118.     {
  119.         if (!$this->rubriques->contains($rubrique)) {
  120.             $this->rubriques->add($rubrique);
  121.             $rubrique->setSection($this);
  122.         }
  124.         return $this;
  125.     }
  127.     public function removeRubrique(Rubrique $rubrique): static
  128.     {
  129.         if ($this->rubriques->removeElement($rubrique)) {
  130.             // set the owning side to null (unless already changed)
  131.             if ($rubrique->getSection() === $this) {
  132.                 $rubrique->setSection(null);
  133.             }
  134.         }
  136.         return $this;
  137.     }
  141.     public function getDocument(): ?Document
  142.     {
  143.         return $this->document;
  144.     }
  146.     public function setDocument(?Document $document): static
  147.     {
  148.         $this->document = $document;
  150.         return $this;
  151.     }
  153.     public function getParentSection(): ?self
  154.     {
  155.         return $this->parentSection;
  156.     }
  158.     public function setParentSection(?self $parentSection): static
  159.     {
  160.         $this->parentSection = $parentSection;
  162.         return $this;
  163.     }
  165.     /**
  166.      * @return Collection<int, self>
  167.      */
  168.     public function getSubSections(): Collection
  169.     {
  170.         return $this->subSections;
  171.     }
  173.     public function addSubSection(self $subSection): static
  174.     {
  175.         if (!$this->subSections->contains($subSection)) {
  176.             $this->subSections->add($subSection);
  177.             $subSection->setParentSection($this);
  178.         }
  180.         return $this;
  181.     }
  183.     public function removeSubSection(self $subSection): static
  184.     {
  185.         if ($this->subSections->removeElement($subSection)) {
  186.             // set the owning side to null (unless already changed)
  187.             if ($subSection->getParentSection() === $this) {
  188.                 $subSection->setParentSection(null);
  189.             }
  190.         }
  192.         return $this;
  193.     }
  195.     /**
  196.      * @return Collection<int, Element>
  197.      */
  198.     public function getElements(): Collection
  199.     {
  200.         return $this->elements;
  201.     }
  203.     public function addElement(Element $element): static
  204.     {
  205.         if (!$this->elements->contains($element)) {
  206.             $this->elements->add($element);
  207.             $element->setSection($this);
  208.         }
  210.         return $this;
  211.     }
  213.     public function removeElement(Element $element): static
  214.     {
  215.         if ($this->elements->removeElement($element)) {
  216.             // set the owning side to null (unless already changed)
  217.             if ($element->getSection() === $this) {
  218.                 $element->setSection(null);
  219.             }
  220.         }
  222.         return $this;
  223.     }
  225.     /**
  226.      * @return Collection<int, Bloc>
  227.      */
  228.     public function getBloc(): Collection
  229.     {
  230.         return $this->bloc;
  231.     }
  233.     public function addBloc(Bloc $bloc): static
  234.     {
  235.         if (!$this->bloc->contains($bloc)) {
  236.             $this->bloc->add($bloc);
  237.             $bloc->setSection($this);
  238.         }
  240.         return $this;
  241.     }
  243.     public function removeBloc(Bloc $bloc): static
  244.     {
  245.         if ($this->bloc->removeElement($bloc)) {
  246.             // set the owning side to null (unless already changed)
  247.             if ($bloc->getSection() === $this) {
  248.                 $bloc->setSection(null);
  249.             }
  250.         }
  252.         return $this;
  253.     }
  255. }