1. <?php
3. namespace App\Entity;
5. use DateTime;
6. use App\Entity\User;
7. use App\Entity\Season;
8. use App\Entity\Expense;
9. use App\Entity\Location;
10. use App\Entity\Classroom;
11. use App\Entity\enums\CompanyCategory;
12. use Symfony\Component\Uid\Ulid;
13. use Doctrine\ORM\Mapping as ORM;
14. use App\Repository\CompanyRepository;
15. use App\Controller\MyCompanyController;
16. use Doctrine\Common\Collections\Collection;
17. use ApiPlatform\Core\Annotation\ApiResource;
18. use Doctrine\Common\Collections\ArrayCollection;
19. use Symfony\Component\Serializer\Annotation\Groups;
20. use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;
21. use Gedmo\Mapping\Annotation as Gedmo;
23. #[ORM\Entity(repositoryClass: CompanyRepository::class)]
24. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
25. #[ORM\HasLifecycleCallbacks()]
26. #[ApiResource(
27.     normalizationContext: [
28.         'groups' => ['read:company']
29.     ],
30.     itemOperations: [
31.         'mycompany' => [
32.             'pagination_enabled' => false,
33.             'path' => '/mycompany',
34.             'method' => 'get',
35.             'requirements' => [],
36.             'controller' => MyCompanyController::class,
37.             'read' => false,
38.         ]
39.     ],
40.     collectionOperations: [],
41. )]
42. class Company
43. {
44.     use Timestamps;
46.     const TYPES = [
47.         'Crèche',
48.         'Jardin d\'enfants',
49.         'Établissement « multi-accueil ».'
50.     ];
52.     #[ORM\Id]
53.     #[ORM\Column(type: 'ulid', unique: true)]
54.     #[ORM\GeneratedValue(strategy: "CUSTOM")]
55.     #[ORM\CustomIdGenerator(class: UlidGenerator::class)]
56.     #[Groups(['read:company'])]
57.     private ?Ulid $id = null;
59.     #[ORM\Column(type: 'string', length: 255)]
60.     #[Groups(['read:company'])]
61.     private $name;
63.     #[ORM\Column(type: 'string', length: 255, enumType: CompanyCategory::class)]
64.     #[Groups(['read:company'])]
65.     private $type;
67.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
68.     #[Groups(['read:company'])]
69.     private $size;
71.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
72.     #[Groups(['read:company'])]
73.     private $logo;
75.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
76.     #[Groups(['read:company'])]
77.     private $email;
79.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
80.     #[Groups(['read:company'])]
81.     private $phone;
83.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
84.     #[Groups(['read:company'])]
85.     private $mobile;
87.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
88.     #[Groups(['read:company'])]
89.     private $fax;
91.     #[ORM\Column(type: 'text', nullable: true)]
92.     #[Groups(['read:company'])]
93.     private $description;
95.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
96.     #[Groups(['read:company'])]
97.     private $website;
99.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
100.     #[Groups(['read:company'])]
101.     private $facebook;
103.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
104.     #[Groups(['read:company'])]
105.     private $twitter;
107.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
108.     #[Groups(['read:company'])]
109.     private $instagram;
111.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
112.     #[Groups(['read:company'])]
113.     private $youtube;
115.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
116.     #[Groups(['read:company'])]
117.     private $tiktok;
119.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
120.     #[Groups(['read:company'])]
121.     private $rc;
123.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
124.     #[Groups(['read:company'])]
125.     private $nif;
127.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
128.     #[Groups(['read:company'])]
129.     private $nis;
131.     #[ORM\Column(type: 'boolean', nullable: true)]
132.     private $is_active;
134.     #[ORM\OneToMany(mappedBy: 'company', targetEntity: User::class)]
135.     private $users;
137.     #[ORM\OneToOne(targetEntity: Location::class, cascade: ['persist', 'remove'])]
138.     #[Groups(['read:company'])]
139.     private $address;
141.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
142.     private $date_format;
144.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
145.     private $languege;
147.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
148.     private $currencie;
150.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
151.     private $time_zone;
153.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Expense::class, orphanRemoval: true)]
154.     private $expenses;
156.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: ExpenseCategory::class, orphanRemoval: true)]
157.     private $expenseCategories;
159.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Season::class, orphanRemoval: true)]
160.     private $seasons;
162.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Service::class, orphanRemoval: true)]
163.     private $services;
165.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Section::class, orphanRemoval: true)]
166.     private $sections;
168.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: FamilyMember::class, orphanRemoval: true)]
169.     private $familyMembers;
171.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Child::class, orphanRemoval: true)]
172.     private $children;
174.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Employee::class, orphanRemoval: true)]
175.     private $employees;
177.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Subscription::class, orphanRemoval: true)]
178.     private $subscriptions;
180.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Payment::class, orphanRemoval: true)]
181.     private $payments;
183.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Classroom::class, orphanRemoval: true)]
184.     private $classrooms;
186.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Evenement::class, orphanRemoval: true)]
187.     private $evenements;
189.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Task::class, orphanRemoval: true)]
190.     private $tasks;
192.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: AbsenceEmployee::class, orphanRemoval: true)]
193.     private $absenceEmployees;
195.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Post::class, orphanRemoval: true)]
196.     private $posts;
198.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Colleague::class, orphanRemoval: true)]
199.     private $colleagues;
201.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Abonnement::class, orphanRemoval: true)]
202.     private $abonnements;
204.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Order::class, orphanRemoval: true)]
205.     private $orders;
207.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Prechild::class, orphanRemoval: true)]
208.     private $prechildren;
210.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Pointing::class, orphanRemoval: true)]
211.     private $pointings;
213.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Activity::class)]
214.     private Collection $activities;
216.     public function __construct()
217.     {
218.         $this->cars = new ArrayCollection();
219.         $this->users = new ArrayCollection();
220.         $this->type = CompanyCategory::creche;
221.         $this->expenses = new ArrayCollection();
222.         $this->expenseCategories = new ArrayCollection();
223.         $this->seasons = new ArrayCollection();
224.         $this->services = new ArrayCollection();
225.         $this->sections = new ArrayCollection();
226.         $this->familyMembers = new ArrayCollection();
227.         $this->children = new ArrayCollection();
228.         $this->employees = new ArrayCollection();
229.         $this->subscriptions = new ArrayCollection();
230.         $this->payments = new ArrayCollection();
231.         $this->classrooms = new ArrayCollection();
232.         $this->evenements = new ArrayCollection();
233.         $this->tasks = new ArrayCollection();
234.         $this->absenceChildren = new ArrayCollection();
235.         $this->absenceEmployees = new ArrayCollection();
236.         $this->posts = new ArrayCollection();
237.         $this->colleagues = new ArrayCollection();
238.         $this->abonnements = new ArrayCollection();
239.         $this->orders = new ArrayCollection();
240.         $this->prechildren = new ArrayCollection();
241.         $this->currencie = 'DZD';
242.         $this->pointings = new ArrayCollection();
243.         $this->activities = new ArrayCollection();
244.     }
246.     public function __toString()
247.     {
248.         return $this->name;
249.     }
251.     public function isTrial()
252.     {
253.         $now = new DateTime();
254.         $interval = $now->diff($this->getCreatedAt(), true);
255.         if (intval($interval->format('%a')) < 30) {
256.             return true;
257.         }
258.         return false;
259.     }
261.     public function hasActivePlan()
262.     {
263.         $abonnements = $this->getAbonnements();
264.         if (count($abonnements) > 0) {
265.             return true;
266.         }
267.         return false;
268.     }
270.     public function getId(): ?Ulid
271.     {
272.         return $this->id;
273.     }
275.     public function getName(): ?string
276.     {
277.         return $this->name;
278.     }
280.     public function setName(string $name): self
281.     {
282.         $this->name = $name;
284.         return $this;
285.     }
287.     public function getLogo(): ?string
288.     {
289.         return $this->logo;
290.     }
292.     public function setLogo(?string $logo): self
293.     {
294.         $this->logo = $logo;
296.         return $this;
297.     }
299.     public function getEmail(): ?string
300.     {
301.         return $this->email;
302.     }
304.     public function setEmail(?string $email): self
305.     {
306.         $this->email = $email;
308.         return $this;
309.     }
311.     public function getPhone(): ?string
312.     {
313.         return $this->phone;
314.     }
316.     public function setPhone(?string $phone): self
317.     {
318.         $this->phone = $phone;
320.         return $this;
321.     }
323.     public function getMobile(): ?string
324.     {
325.         return $this->mobile;
326.     }
328.     public function setMobile(?string $mobile): self
329.     {
330.         $this->mobile = $mobile;
332.         return $this;
333.     }
335.     public function getFax(): ?string
336.     {
337.         return $this->fax;
338.     }
340.     public function setFax(?string $fax): self
341.     {
342.         $this->fax = $fax;
344.         return $this;
345.     }
347.     public function getDescription(): ?string
348.     {
349.         return $this->description;
350.     }
352.     public function setDescription(?string $description): self
353.     {
354.         $this->description = $description;
356.         return $this;
357.     }
359.     public function getWebsite(): ?string
360.     {
361.         return $this->website;
362.     }
364.     public function setWebsite(?string $website): self
365.     {
366.         $this->website = $website;
368.         return $this;
369.     }
371.     public function getFacebook(): ?string
372.     {
373.         return $this->facebook;
374.     }
376.     public function setFacebook(?string $facebook): self
377.     {
378.         $this->facebook = $facebook;
380.         return $this;
381.     }
383.     public function getTwitter(): ?string
384.     {
385.         return $this->twitter;
386.     }
388.     public function setTwitter(?string $twitter): self
389.     {
390.         $this->twitter = $twitter;
392.         return $this;
393.     }
395.     public function getInstagram(): ?string
396.     {
397.         return $this->instagram;
398.     }
400.     public function setInstagram(?string $instagram): self
401.     {
402.         $this->instagram = $instagram;
404.         return $this;
405.     }
407.     public function getYoutube(): ?string
408.     {
409.         return $this->youtube;
410.     }
412.     public function setYoutube(?string $youtube): self
413.     {
414.         $this->youtube = $youtube;
416.         return $this;
417.     }
419.     public function getTiktok(): ?string
420.     {
421.         return $this->tiktok;
422.     }
424.     public function setTiktok(?string $tiktok): self
425.     {
426.         $this->tiktok = $tiktok;
428.         return $this;
429.     }
431.     public function getRc(): ?string
432.     {
433.         return $this->rc;
434.     }
436.     public function setRc(?string $rc): self
437.     {
438.         $this->rc = $rc;
440.         return $this;
441.     }
443.     public function getNif(): ?string
444.     {
445.         return $this->nif;
446.     }
448.     public function setNif(?string $nif): self
449.     {
450.         $this->nif = $nif;
452.         return $this;
453.     }
455.     public function getNis(): ?string
456.     {
457.         return $this->nis;
458.     }
460.     public function setNis(?string $nis): self
461.     {
462.         $this->nis = $nis;
464.         return $this;
465.     }
467.     public function getIsActive(): ?bool
468.     {
469.         return $this->is_active;
470.     }
472.     public function setIsActive(bool $is_active): self
473.     {
474.         $this->is_active = $is_active;
476.         return $this;
477.     }
479.     public function getType(): ?CompanyCategory
480.     {
481.         return $this->type;
482.     }
484.     public function setType(?CompanyCategory $type): self
485.     {
486.         $this->type = $type;
488.         return $this;
489.     }
491.     /**
492.      * @return Collection<int, User>
493.      */
494.     public function getUsers(): Collection
495.     {
496.         return $this->users;
497.     }
499.     public function addUser(User $user): self
500.     {
501.         if (!$this->users->contains($user)) {
502.             $this->users[] = $user;
503.             $user->setCompany($this);
504.         }
506.         return $this;
507.     }
509.     public function removeUser(User $user): self
510.     {
511.         if ($this->users->removeElement($user)) {
512.             // set the owning side to null (unless already changed)
513.             if ($user->getCompany() === $this) {
514.                 $user->setCompany(null);
515.             }
516.         }
518.         return $this;
519.     }
521.     public function getSize(): ?string
522.     {
523.         return $this->size;
524.     }
526.     public function setSize(?string $size): self
527.     {
528.         $this->size = $size;
530.         return $this;
531.     }
533.     public function getAddress(): ?Location
534.     {
535.         return $this->address;
536.     }
538.     public function setAddress(?Location $address): self
539.     {
540.         $this->address = $address;
542.         return $this;
543.     }
545.     public function getDateFormat(): ?string
546.     {
547.         return $this->date_format;
548.     }
550.     public function setDateFormat(?string $date_format): self
551.     {
552.         $this->date_format = $date_format;
554.         return $this;
555.     }
557.     public function getLanguege(): ?string
558.     {
559.         return $this->languege;
560.     }
562.     public function setLanguege(?string $languege): self
563.     {
564.         $this->languege = $languege;
566.         return $this;
567.     }
569.     public function getCurrencie(): ?string
570.     {
571.         return $this->currencie;
572.     }
574.     public function setCurrencie(?string $currencie): self
575.     {
576.         $this->currencie = $currencie;
578.         return $this;
579.     }
581.     public function getTimeZone(): ?string
582.     {
583.         return $this->time_zone;
584.     }
586.     public function setTimeZone(?string $time_zone): self
587.     {
588.         $this->time_zone = $time_zone;
590.         return $this;
591.     }
593.     /**
594.      * @return Collection<int, Expense>
595.      */
596.     public function getExpenses(): Collection
597.     {
598.         return $this->expenses;
599.     }
601.     public function addExpense(Expense $expense): self
602.     {
603.         if (!$this->expenses->contains($expense)) {
604.             $this->expenses[] = $expense;
605.             $expense->setOwner($this);
606.         }
608.         return $this;
609.     }
611.     public function removeExpense(Expense $expense): self
612.     {
613.         if ($this->expenses->removeElement($expense)) {
614.             // set the owning side to null (unless already changed)
615.             if ($expense->getOwner() === $this) {
616.                 $expense->setOwner(null);
617.             }
618.         }
620.         return $this;
621.     }
623.     /**
624.      * @return Collection<int, ExpenseCategory>
625.      */
626.     public function getExpenseCategories(): Collection
627.     {
628.         return $this->expenseCategories;
629.     }
631.     public function addExpenseCategory(ExpenseCategory $expenseCategory): self
632.     {
633.         if (!$this->expenseCategories->contains($expenseCategory)) {
634.             $this->expenseCategories[] = $expenseCategory;
635.             $expenseCategory->setOwner($this);
636.         }
638.         return $this;
639.     }
641.     public function removeExpenseCategory(ExpenseCategory $expenseCategory): self
642.     {
643.         if ($this->expenseCategories->removeElement($expenseCategory)) {
644.             // set the owning side to null (unless already changed)
645.             if ($expenseCategory->getOwner() === $this) {
646.                 $expenseCategory->setOwner(null);
647.             }
648.         }
650.         return $this;
651.     }
653.     /**
654.      * @return Collection<int, Season>
655.      */
656.     public function getSeasons(): Collection
657.     {
658.         return $this->seasons;
659.     }
661.     public function addSeason(Season $season): self
662.     {
663.         if (!$this->seasons->contains($season)) {
664.             $this->seasons[] = $season;
665.             $season->setOwner($this);
666.         }
668.         return $this;
669.     }
671.     public function getActiveSeason(): Season|null
672.     {
673.         $seasons = $this->getSeasons();
674.         foreach ($seasons as $season) {
675.             if ($season->isIsActive()) {
676.                 return $season;
677.             }
678.         }
679.         return null;
680.     }
682.     public function removeSeason(Season $season): self
683.     {
684.         if ($this->seasons->removeElement($season)) {
685.             // set the owning side to null (unless already changed)
686.             if ($season->getOwner() === $this) {
687.                 $season->setOwner(null);
688.             }
689.         }
691.         return $this;
692.     }
694.     /**
695.      * @return Collection<int, Service>
696.      */
697.     public function getServices(): Collection
698.     {
699.         return $this->services;
700.     }
702.     public function addService(Service $service): self
703.     {
704.         if (!$this->services->contains($service)) {
705.             $this->services[] = $service;
706.             $service->setOwner($this);
707.         }
709.         return $this;
710.     }
712.     public function removeService(Service $service): self
713.     {
714.         if ($this->services->removeElement($service)) {
715.             // set the owning side to null (unless already changed)
716.             if ($service->getOwner() === $this) {
717.                 $service->setOwner(null);
718.             }
719.         }
721.         return $this;
722.     }
724.     /**
725.      * @return Collection<int, Section>
726.      */
727.     public function getSections(): Collection
728.     {
729.         return $this->sections;
730.     }
732.     public function addSection(Section $section): self
733.     {
734.         if (!$this->sections->contains($section)) {
735.             $this->sections[] = $section;
736.             $section->setOwner($this);
737.         }
739.         return $this;
740.     }
742.     public function removeSection(Section $section): self
743.     {
744.         if ($this->sections->removeElement($section)) {
745.             // set the owning side to null (unless already changed)
746.             if ($section->getOwner() === $this) {
747.                 $section->setOwner(null);
748.             }
749.         }
751.         return $this;
752.     }
754.     /**
755.      * @return Collection<int, FamilyMember>
756.      */
757.     public function getFamilyMembers(): Collection
758.     {
759.         return $this->familyMembers;
760.     }
762.     public function addFamilyMember(FamilyMember $familyMember): self
763.     {
764.         if (!$this->familyMembers->contains($familyMember)) {
765.             $this->familyMembers[] = $familyMember;
766.             $familyMember->setOwner($this);
767.         }
769.         return $this;
770.     }
772.     public function removeFamilyMember(FamilyMember $familyMember): self
773.     {
774.         if ($this->familyMembers->removeElement($familyMember)) {
775.             // set the owning side to null (unless already changed)
776.             if ($familyMember->getOwner() === $this) {
777.                 $familyMember->setOwner(null);
778.             }
779.         }
781.         return $this;
782.     }
784.     /**
785.      * @return Collection<int, Child>
786.      */
787.     public function getChildren(): Collection
788.     {
789.         return $this->children;
790.     }
792.     public function addChild(Child $child): self
793.     {
794.         if (!$this->children->contains($child)) {
795.             $this->children[] = $child;
796.             $child->setOwner($this);
797.         }
799.         return $this;
800.     }
802.     public function removeChild(Child $child): self
803.     {
804.         if ($this->children->removeElement($child)) {
805.             // set the owning side to null (unless already changed)
806.             if ($child->getOwner() === $this) {
807.                 $child->setOwner(null);
808.             }
809.         }
811.         return $this;
812.     }
814.     /**
815.      * @return Collection<int, Employee>
816.      */
817.     public function getEmployees(): Collection
818.     {
819.         return $this->employees;
820.     }
822.     public function addEmployee(Employee $employee): self
823.     {
824.         if (!$this->employees->contains($employee)) {
825.             $this->employees[] = $employee;
826.             $employee->setOwner($this);
827.         }
829.         return $this;
830.     }
832.     public function removeEmployee(Employee $employee): self
833.     {
834.         if ($this->employees->removeElement($employee)) {
835.             // set the owning side to null (unless already changed)
836.             if ($employee->getOwner() === $this) {
837.                 $employee->setOwner(null);
838.             }
839.         }
841.         return $this;
842.     }
844.     /**
845.      * @return Collection<int, Subscription>
846.      */
847.     public function getSubscriptions(): Collection
848.     {
849.         return $this->subscriptions;
850.     }
852.     public function addSubscription(Subscription $subscription): self
853.     {
854.         if (!$this->subscriptions->contains($subscription)) {
855.             $this->subscriptions[] = $subscription;
856.             $subscription->setOwner($this);
857.         }
859.         return $this;
860.     }
862.     public function removeSubscription(Subscription $subscription): self
863.     {
864.         if ($this->subscriptions->removeElement($subscription)) {
865.             // set the owning side to null (unless already changed)
866.             if ($subscription->getOwner() === $this) {
867.                 $subscription->setOwner(null);
868.             }
869.         }
871.         return $this;
872.     }
874.     /**
875.      * @return Collection<int, Payment>
876.      */
877.     public function getPayments(): Collection
878.     {
879.         return $this->payments;
880.     }
882.     public function addPayment(Payment $payment): self
883.     {
884.         if (!$this->payments->contains($payment)) {
885.             $this->payments[] = $payment;
886.             $payment->setOwner($this);
887.         }
889.         return $this;
890.     }
892.     public function removePayment(Payment $payment): self
893.     {
894.         if ($this->payments->removeElement($payment)) {
895.             // set the owning side to null (unless already changed)
896.             if ($payment->getOwner() === $this) {
897.                 $payment->setOwner(null);
898.             }
899.         }
901.         return $this;
902.     }
904.     /**
905.      * @return Collection<int, Classroom>
906.      */
907.     public function getClassrooms(): Collection
908.     {
909.         return $this->classrooms;
910.     }
912.     public function addClassroom(Classroom $classroom): self
913.     {
914.         if (!$this->classrooms->contains($classroom)) {
915.             $this->classrooms[] = $classroom;
916.             $classroom->setOwner($this);
917.         }
919.         return $this;
920.     }
922.     public function removeClassroom(Classroom $classroom): self
923.     {
924.         if ($this->classrooms->removeElement($classroom)) {
925.             // set the owning side to null (unless already changed)
926.             if ($classroom->getOwner() === $this) {
927.                 $classroom->setOwner(null);
928.             }
929.         }
931.         return $this;
932.     }
934.     /**
935.      * @return Collection<int, Evenement>
936.      */
937.     public function getEvenements(): Collection
938.     {
939.         return $this->evenements;
940.     }
942.     public function addEvenement(Evenement $evenement): self
943.     {
944.         if (!$this->evenements->contains($evenement)) {
945.             $this->evenements[] = $evenement;
946.             $evenement->setOwner($this);
947.         }
949.         return $this;
950.     }
952.     public function removeEvenement(Evenement $evenement): self
953.     {
954.         if ($this->evenements->removeElement($evenement)) {
955.             // set the owning side to null (unless already changed)
956.             if ($evenement->getOwner() === $this) {
957.                 $evenement->setOwner(null);
958.             }
959.         }
961.         return $this;
962.     }
964.     /**
965.      * @return Collection<int, Task>
966.      */
967.     public function getTasks(): Collection
968.     {
969.         return $this->tasks;
970.     }
972.     public function addTask(Task $task): self
973.     {
974.         if (!$this->tasks->contains($task)) {
975.             $this->tasks[] = $task;
976.             $task->setOwner($this);
977.         }
979.         return $this;
980.     }
982.     public function removeTask(Task $task): self
983.     {
984.         if ($this->tasks->removeElement($task)) {
985.             // set the owning side to null (unless already changed)
986.             if ($task->getOwner() === $this) {
987.                 $task->setOwner(null);
988.             }
989.         }
991.         return $this;
992.     }
994.     /**
995.      * @return Collection<int, AbsenceEmployee>
996.      */
997.     public function getAbsenceEmployees(): Collection
998.     {
999.         return $this->absenceEmployees;
1000.     }
1002.     public function addAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
1003.     {
1004.         if (!$this->absenceEmployees->contains($absenceEmployee)) {
1005.             $this->absenceEmployees[] = $absenceEmployee;
1006.             $absenceEmployee->setOwner($this);
1007.         }
1009.         return $this;
1010.     }
1012.     public function removeAbsenceEmployee(AbsenceEmployee $absenceEmployee): self
1013.     {
1014.         if ($this->absenceEmployees->removeElement($absenceEmployee)) {
1015.             // set the owning side to null (unless already changed)
1016.             if ($absenceEmployee->getOwner() === $this) {
1017.                 $absenceEmployee->setOwner(null);
1018.             }
1019.         }
1021.         return $this;
1022.     }
1024.     /**
1025.      * @return Collection<int, Post>
1026.      */
1027.     public function getPosts(): Collection
1028.     {
1029.         return $this->posts;
1030.     }
1032.     public function addPost(Post $post): self
1033.     {
1034.         if (!$this->posts->contains($post)) {
1035.             $this->posts[] = $post;
1036.             $post->setOwner($this);
1037.         }
1039.         return $this;
1040.     }
1042.     public function removePost(Post $post): self
1043.     {
1044.         if ($this->posts->removeElement($post)) {
1045.             // set the owning side to null (unless already changed)
1046.             if ($post->getOwner() === $this) {
1047.                 $post->setOwner(null);
1048.             }
1049.         }
1051.         return $this;
1052.     }
1054.     /**
1055.      * @return Collection<int, Colleague>
1056.      */
1057.     public function getColleagues(): Collection
1058.     {
1059.         return $this->colleagues;
1060.     }
1062.     public function addColleague(Colleague $colleague): self
1063.     {
1064.         if (!$this->colleagues->contains($colleague)) {
1065.             $this->colleagues[] = $colleague;
1066.             $colleague->setOwner($this);
1067.         }
1069.         return $this;
1070.     }
1072.     public function removeColleague(Colleague $colleague): self
1073.     {
1074.         if ($this->colleagues->removeElement($colleague)) {
1075.             // set the owning side to null (unless already changed)
1076.             if ($colleague->getOwner() === $this) {
1077.                 $colleague->setOwner(null);
1078.             }
1079.         }
1081.         return $this;
1082.     }
1084.     /**
1085.      * @return Collection<int, Abonnement>
1086.      */
1087.     public function getAbonnements(): Collection
1088.     {
1089.         foreach ($this->abonnements as $key => $value) {
1090.             if ($value->getExpireDate() < new DateTime()) {
1091.                 $this->abonnements->remove($key);
1092.             }
1093.         }
1094.         return $this->abonnements;
1095.     }
1097.     public function addAbonnement(Abonnement $abonnement): self
1098.     {
1099.         if (!$this->abonnements->contains($abonnement)) {
1100.             $this->abonnements[] = $abonnement;
1101.             $abonnement->setOwner($this);
1102.         }
1104.         return $this;
1105.     }
1107.     public function removeAbonnement(Abonnement $abonnement): self
1108.     {
1109.         if ($this->abonnements->removeElement($abonnement)) {
1110.             // set the owning side to null (unless already changed)
1111.             if ($abonnement->getOwner() === $this) {
1112.                 $abonnement->setOwner(null);
1113.             }
1114.         }
1116.         return $this;
1117.     }
1119.     /**
1120.      * @return Collection<int, Order>
1121.      */
1122.     public function getOrders(): Collection
1123.     {
1124.         return $this->orders;
1125.     }
1127.     public function addOrder(Order $order): self
1128.     {
1129.         if (!$this->orders->contains($order)) {
1130.             $this->orders[] = $order;
1131.             $order->setOwner($this);
1132.         }
1134.         return $this;
1135.     }
1137.     public function removeOrder(Order $order): self
1138.     {
1139.         if ($this->orders->removeElement($order)) {
1140.             // set the owning side to null (unless already changed)
1141.             if ($order->getOwner() === $this) {
1142.                 $order->setOwner(null);
1143.             }
1144.         }
1146.         return $this;
1147.     }
1149.     /**
1150.      * @return Collection<int, Prechild>
1151.      */
1152.     public function getPrechildren(): Collection
1153.     {
1154.         return $this->prechildren;
1155.     }
1157.     public function addPrechild(Prechild $prechild): self
1158.     {
1159.         if (!$this->prechildren->contains($prechild)) {
1160.             $this->prechildren[] = $prechild;
1161.             $prechild->setOwner($this);
1162.         }
1164.         return $this;
1165.     }
1167.     public function removePrechild(Prechild $prechild): self
1168.     {
1169.         if ($this->prechildren->removeElement($prechild)) {
1170.             // set the owning side to null (unless already changed)
1171.             if ($prechild->getOwner() === $this) {
1172.                 $prechild->setOwner(null);
1173.             }
1174.         }
1176.         return $this;
1177.     }
1179.     /**
1180.      * @return Collection<int, Pointing>
1181.      */
1182.     public function getPointings(): Collection
1183.     {
1184.         return $this->pointings;
1185.     }
1187.     public function addPointing(Pointing $pointing): self
1188.     {
1189.         if (!$this->pointings->contains($pointing)) {
1190.             $this->pointings[] = $pointing;
1191.             $pointing->setOwner($this);
1192.         }
1194.         return $this;
1195.     }
1197.     public function removePointing(Pointing $pointing): self
1198.     {
1199.         if ($this->pointings->removeElement($pointing)) {
1200.             // set the owning side to null (unless already changed)
1201.             if ($pointing->getOwner() === $this) {
1202.                 $pointing->setOwner(null);
1203.             }
1204.         }
1206.         return $this;
1207.     }
1209.     public function isIsActive(): ?bool
1210.     {
1211.         return $this->is_active;
1212.     }
1214.     /**
1215.      * @return Collection<int, Activity>
1216.      */
1217.     public function getActivities(): Collection
1218.     {
1219.         return $this->activities;
1220.     }
1222.     public function addActivity(Activity $activity): static
1223.     {
1224.         if (!$this->activities->contains($activity)) {
1225.             $this->activities->add($activity);
1226.             $activity->setOwner($this);
1227.         }
1229.         return $this;
1230.     }
1232.     public function removeActivity(Activity $activity): static
1233.     {
1234.         if ($this->activities->removeElement($activity)) {
1235.             // set the owning side to null (unless already changed)
1236.             if ($activity->getOwner() === $this) {
1237.                 $activity->setOwner(null);
1238.             }
1239.         }
1241.         return $this;
1242.     }
1244.     public function getOwner(): User|null
1245.     {
1246.         foreach ($this->users as $user) {
1247.             if (in_array('ROLE_OWNER', $user->getRoles())) {
1248.                 return $user;
1249.             }
1250.         }
1251.         return null;
1252.     }
1253. }