src/Entity/Statut.php line 10

1. <?php
3. namespace App\Entity;
5. use Doctrine\Common\Collections\ArrayCollection;
6. use Doctrine\Common\Collections\Collection;
7. use Doctrine\ORM\Mapping as ORM;
9. #[ORM\Entity(repositoryClass: \App\Repository\StatutRepository::class)]
10. class Statut implements \Stringable
11. {
12.     #[ORM\Id]
13.     #[ORM\GeneratedValue]
14.     #[ORM\Column(type: 'integer')]
15.     private int $id;
17.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
18.     private ?string $name= null;
20.     #[ORM\OneToMany(targetEntity: \App\Entity\Post::class, mappedBy: 'status')]
21.     private mixed $posts;
23.     #[ORM\OneToMany(targetEntity: \App\Entity\Post::class, mappedBy: 'old_status')]
24.     private mixed $oldposts;
26.     #[ORM\OneToMany(targetEntity: Document::class, mappedBy: 'statut')]
27.     private mixed $documents;
29.     #[ORM\OneToMany(targetEntity: PolitiqueDepartementale::class, mappedBy: 'statut')]
30.     private mixed $politiqueDepartementales;
32.     #[ORM\OneToMany(targetEntity: Service::class, mappedBy: 'statut')]
33.     private mixed $services;
35.     #[ORM\OneToMany(mappedBy: 'statut', targetEntity: PageSatellite::class)]
36.     private Collection $pageSatellites;
38.     public function __construct()
39.     {
40.         $this->posts = new ArrayCollection();
41.         $this->oldposts = new ArrayCollection();
42.         $this->documents = new ArrayCollection();
43.         $this->politiqueDepartementales = new ArrayCollection();
44.         $this->services = new ArrayCollection();
45.         $this->pageSatellites = new ArrayCollection();
46.     }
48.     public function getId(): ?int
49.     {
50.         return $this->id;
51.     }
53.     public function getName(): ?string
54.     {
55.         return $this->name;
56.     }
58.     public function setName(?string $name): self
59.     {
60.         $this->name = $name;
62.         return $this;
63.     }
65.     /**
66.      * @return Collection|Post[]
67.      */
68.     public function getPosts(): Collection
69.     {
70.         return $this->posts;
71.     }
73.     public function addPost(Post $post): self
74.     {
75.         if (!$this->posts->contains($post)) {
76.             $this->posts[] = $post;
77.             $post->setStatus($this);
78.         }
80.         return $this;
81.     }
83.     public function removePost(Post $post): self
84.     {
85.         if ($this->posts->contains($post)) {
86.             $this->posts->removeElement($post);
87.             // set the owning side to null (unless already changed)
88.             if ($post->getStatus() === $this) {
89.                 $post->setStatus(null);
90.             }
91.         }
93.         return $this;
94.     }
95.     public function __toString(): string
96.     {
97.         return (string) $this->name;
98.     }
100.     /**
101.      * @return Collection|Post[]
102.      */
103.     public function getOldposts(): Collection
104.     {
105.         return $this->oldposts;
106.     }
108.     public function addOldpost(Post $oldpost): self
109.     {
110.         if (!$this->oldposts->contains($oldpost)) {
111.             $this->oldposts[] = $oldpost;
112.             $oldpost->setOldStatus($this);
113.         }
115.         return $this;
116.     }
118.     public function removeOldpost(Post $oldpost): self
119.     {
120.         if ($this->oldposts->contains($oldpost)) {
121.             $this->oldposts->removeElement($oldpost);
122.             // set the owning side to null (unless already changed)
123.             if ($oldpost->getOldStatus() === $this) {
124.                 $oldpost->setOldStatus(null);
125.             }
126.         }
128.         return $this;
129.     }
131.     /**
132.      * @return Collection|Document[]
133.      */
134.     public function getDocuments(): Collection
135.     {
136.         return $this->documents;
137.     }
139.     public function addDocument(Document $document): self
140.     {
141.         if (!$this->documents->contains($document)) {
142.             $this->documents[] = $document;
143.             $document->setStatut($this);
144.         }
146.         return $this;
147.     }
149.     public function removeDocument(Document $document): self
150.     {
151.         if ($this->documents->removeElement($document)) {
152.             // set the owning side to null (unless already changed)
153.             if ($document->getStatut() === $this) {
154.                 $document->setStatut(null);
155.             }
156.         }
158.         return $this;
159.     }
161.     /**
162.      * @return Collection|PolitiqueDepartementale[]
163.      */
164.     public function getPolitiqueDepartementales(): Collection
165.     {
166.         return $this->politiqueDepartementales;
167.     }
169.     public function addPolitiqueDepartementale(PolitiqueDepartementale $politiqueDepartementale): self
170.     {
171.         if (!$this->politiqueDepartementales->contains($politiqueDepartementale)) {
172.             $this->politiqueDepartementales[] = $politiqueDepartementale;
173.             $politiqueDepartementale->setStatut($this);
174.         }
176.         return $this;
177.     }
179.     public function removePolitiqueDepartementale(PolitiqueDepartementale $politiqueDepartementale): self
180.     {
181.         if ($this->politiqueDepartementales->removeElement($politiqueDepartementale)) {
182.             // set the owning side to null (unless already changed)
183.             if ($politiqueDepartementale->getStatut() === $this) {
184.                 $politiqueDepartementale->setStatut(null);
185.             }
186.         }
188.         return $this;
189.     }
191.     /**
192.      * @return Collection|Service[]
193.      */
194.     public function getServices(): Collection
195.     {
196.         return $this->services;
197.     }
199.     public function addService(Service $service): self
200.     {
201.         if (!$this->services->contains($service)) {
202.             $this->services[] = $service;
203.             $service->setStatut($this);
204.         }
206.         return $this;
207.     }
209.     public function removeService(Service $service): self
210.     {
211.         if ($this->services->removeElement($service)) {
212.             // set the owning side to null (unless already changed)
213.             if ($service->getStatut() === $this) {
214.                 $service->setStatut(null);
215.             }
216.         }
218.         return $this;
219.     }
221.     /**
222.      * @return Collection<int, PageSatellite>
223.      */
224.     public function getPageSatellites(): Collection
225.     {
226.         return $this->pageSatellites;
227.     }
229.     public function addPageSatellite(PageSatellite $pageSatellite): self
230.     {
231.         if (!$this->pageSatellites->contains($pageSatellite)) {
232.             $this->pageSatellites->add($pageSatellite);
233.             $pageSatellite->setStatut($this);
234.         }
236.         return $this;
237.     }
239.     public function removePageSatellite(PageSatellite $pageSatellite): self
240.     {
241.         if ($this->pageSatellites->removeElement($pageSatellite)) {
242.             // set the owning side to null (unless already changed)
243.             if ($pageSatellite->getStatut() === $this) {
244.                 $pageSatellite->setStatut(null);
245.             }
246.         }
248.         return $this;
249.     }
250. }