src/Entity/SchoolYear.php line 16

1. <?php
3. namespace App\Entity;
5. use App\Repository\SchoolYearRepository;
6. use Doctrine\Common\Collections\ArrayCollection;
7. use Doctrine\Common\Collections\Collection;
8. use Doctrine\ORM\Mapping as ORM;
9. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
11. use App\Entity\Traits\Timestampable;
13. #[ORM\HasLifecycleCallbacks]
14. #[ORM\Entity(repositoryClass: SchoolYearRepository::class)]
15. #[UniqueEntity(fields: ['name'], message: 'cette année existe deja')]
16. class SchoolYear
17. {
18.     use Timestampable;
19.     #[ORM\Id]
20.     #[ORM\GeneratedValue]
21.     #[ORM\Column]
22.     private ?int $id = null;
24.     #[ORM\Column(length: 255)]
25.     private ?string $name = null;
27.     #[ORM\Column]
28.     private ?bool $active = null;
30.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: UserYear::class)]
31.     private Collection $userYears;
33.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: StudentYear::class)]
34.     private Collection $studentYears;
36.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HomeWork::class)]
37.     private Collection $homeWorks;
39.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HomeWorkYear::class)]
40.     private Collection $homeWorkYears;
42.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Late::class)]
43.     private Collection $lates;
45.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Chat::class)]
46.     private Collection $chats;
47.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Absence::class)]
48.     private Collection $absences;
50.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Note::class)]
51.     private Collection $notes;
53.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Exams::class)]
54.     private Collection $exams;
56.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DocInfo::class)]
57.     private Collection $docInfos;
59.     #[ORM\ManyToOne(inversedBy: 'schoolYears', cascade: ["persist"])]
60.     private ?User $author = null;
62.     #[ORM\ManyToOne(inversedBy: 'schoolYearsEdited', cascade: ["persist"])]
63.     private ?User $editor = null;
64.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Punish::class)]
65.     private Collection $punishes;
67.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Discussion::class)]
68.     private Collection $discussions;
70.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DiscussionClass::class)]
71.     private Collection $discussionClasses;
73.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Agenda::class)]
74.     private Collection $agendas;
76.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ExamAgenda::class)]
77.     private Collection $examAgendas;
79.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Quarter::class, orphanRemoval: true)]
80.     private Collection $quarters;
82.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalQuarter::class)]
83.     private Collection $globalQuarters;
85.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Appreciation::class, orphanRemoval: true)]
86.     private Collection $appreciations;
87.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: LocalAccount::class)]
88.     private Collection $localAccounts;
90.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineWarning::class)]
91.     private Collection $disciplineWarnings;
93.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineBlame::class)]
94.     private Collection $disciplineBlames;
96.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineExclusion::class)]
97.     private Collection $disciplineExclusions;
99.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ParentNote::class)]
100.     private Collection $parentNotes;
102.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: JustifyAbsence::class)]
103.     private Collection $justifyAbsences;
105.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Subject::class)]
106.     private Collection $subjects;
108.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceRetainedConfig::class)]
109.     private Collection $absenceRetainedConfigs;
111.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceWarningConfig::class)]
112.     private Collection $absenceWarningConfigs;
114.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceExclusionConfig::class)]
115.     private Collection $absenceExclusionConfigs;
117.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceBlameConfig::class)]
118.     private Collection $absenceBlameConfigs;
120.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineRetained::class)]
121.     private Collection $disciplineRetaineds;
123.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DefinitiveExclusion::class)]
124.     private Collection $definitiveExclusions;
126.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineConcile::class)]
127.     private Collection $disciplineConciles;
129.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceDisciplineConcileConfig::class)]
130.     private Collection $absenceDisciplineConcileConfigs;
132.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningBlameConfig::class)]
133.     private Collection $warningBlameConfigs;
135.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningDefinitiveExlusionConfig::class)]
136.     private Collection $warningDefinitiveExlusionConfigs;
138.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PrimaryParentNote::class)]
139.     private Collection $primaryParentNotes;
141.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PrimaryNote::class)]
142.     private Collection $primaryNotes;
144.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: VerbalProcessCategory::class)]
145.     private Collection $verbalProcessCategories;
147.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalDisciplineConfig::class)]
148.     private Collection $globalDisciplineConfigs;
150.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplinePunish::class)]
151.     private Collection $disciplinePunishes;
153.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalDisciplineEnabledConfig::class)]
154.     private Collection $globalDisciplineEnabledConfigs;
156.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: BlamePunishConfig::class)]
157.     private Collection $blamePunishConfigs;
159.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsencePunishConfig::class)]
160.     private Collection $absencePunishConfigs;
162.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningPunishConfig::class)]
163.     private Collection $warningPunishConfigs;
165.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishRetainedConfig::class)]
166.     private Collection $punishRetainedConfigs;
168.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishWarningConfig::class)]
169.     private Collection $punishWarningConfigs;
171.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishBlameConfig::class)]
172.     private Collection $punishBlameConfigs;
174.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishExclusionConfig::class)]
175.     private Collection $punishExclusionConfigs;
177.     #[ORM\Column(length: 255)]
178.     private ?string $nameEn = null;
180.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: SchoolYearInfos::class)]
181.     private Collection $schoolYearInfos;
183.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Blame::class)]
184.     private Collection $blames;
186.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Warning::class)]
187.     private Collection $warnings;
189.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Retained::class)]
190.     private Collection $retaineds;
192.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HonnorTableLimitMoy::class)]
193.     private Collection $honnorTableLimitMoys;
195.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: News::class)]
196.     private Collection $news;
198.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Event::class)]
199.     private Collection $events;
201.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AdmissionLimit::class)]
202.     private Collection $admissionLimits;
204.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AgendaDay::class)]
205.     private Collection $agendaDays;
207.     #[ORM\OneToOne(mappedBy: 'year', cascade: ['persist'])]
208.     private ?AgendaTimeConvertion $agendaTimeConvertion = null;
210.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ExamWeek::class)]
211.     private Collection $examWeeks;
213.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Competence::class)]
214.     private Collection $competences;
216.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WeekSubjectGoal::class)]
217.     private Collection $weekSubjectGoals;
219.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ProfSchoolPlanner::class)]
220.     private Collection $profSchoolPlanners;
222.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ProfTime::class)]
223.     private Collection $profTimes;
225.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: SchoolPlannerType::class)]
226.     private Collection $schoolPlannerTypes;
228.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AgendaElement::class)]
229.     private Collection $agendaElements;
231.     public function __construct()
232.     {
233.         $this->userYears = new ArrayCollection();
234.         $this->studentYears = new ArrayCollection();
235.         $this->homeWorks = new ArrayCollection();
236.         $this->homeWorkYears = new ArrayCollection();
237.         $this->lates = new ArrayCollection();
238.         $this->chats = new ArrayCollection();
239.         $this->absences = new ArrayCollection();
240.         $this->notes = new ArrayCollection();
241.         $this->exams = new ArrayCollection();
242.         $this->docInfos = new ArrayCollection();
243.         $this->punishes = new ArrayCollection();
244.         $this->discussions = new ArrayCollection();
245.         $this->discussionClasses = new ArrayCollection();
246.         $this->agendas = new ArrayCollection();
247.         $this->examAgendas = new ArrayCollection();
248.         $this->quarters = new ArrayCollection();
249.         $this->globalQuarters = new ArrayCollection();
250.         $this->appreciations = new ArrayCollection();
251.         $this->localAccounts = new ArrayCollection();
252.         $this->disciplineWarnings = new ArrayCollection();
253.         $this->disciplineBlames = new ArrayCollection();
254.         $this->disciplineExclusions = new ArrayCollection();
255.         $this->parentNotes = new ArrayCollection();
256.         $this->justifyAbsences = new ArrayCollection();
257.         $this->subjects = new ArrayCollection();
258.         $this->absenceRetainedConfigs = new ArrayCollection();
259.         $this->absenceWarningConfigs = new ArrayCollection();
260.         $this->absenceExclusionConfigs = new ArrayCollection();
261.         $this->absenceBlameConfigs = new ArrayCollection();
262.         $this->disciplineRetaineds = new ArrayCollection();
263.         $this->definitiveExclusions = new ArrayCollection();
264.         $this->disciplineConciles = new ArrayCollection();
265.         $this->absenceDisciplineConcileConfigs = new ArrayCollection();
266.         $this->warningBlameConfigs = new ArrayCollection();
267.         $this->warningDefinitiveExlusionConfigs = new ArrayCollection();
268.         $this->primaryParentNotes = new ArrayCollection();
269.         $this->primaryNotes = new ArrayCollection();
270.         $this->verbalProcessCategories = new ArrayCollection();
271.         $this->globalDisciplineConfigs = new ArrayCollection();
272.         $this->disciplinePunishes = new ArrayCollection();
273.         $this->globalDisciplineEnabledConfigs = new ArrayCollection();
274.         $this->blamePunishConfigs = new ArrayCollection();
275.         $this->absencePunishConfigs = new ArrayCollection();
276.         $this->warningPunishConfigs = new ArrayCollection();
277.         $this->punishRetainedConfigs = new ArrayCollection();
278.         $this->punishWarningConfigs = new ArrayCollection();
279.         $this->punishBlameConfigs = new ArrayCollection();
280.         $this->punishExclusionConfigs = new ArrayCollection();
281.         $this->schoolYearInfos = new ArrayCollection();
282.         $this->blames = new ArrayCollection();
283.         $this->warnings = new ArrayCollection();
284.         $this->retaineds = new ArrayCollection();
285.         $this->honnorTableLimitMoys = new ArrayCollection();
286.         $this->news = new ArrayCollection();
287.         $this->events = new ArrayCollection();
288.         $this->admissionLimits = new ArrayCollection();
289.         $this->agendaDays = new ArrayCollection();
290.         $this->examWeeks = new ArrayCollection();
291.         $this->competences = new ArrayCollection();
292.         $this->weekSubjectGoals = new ArrayCollection();
293.         $this->profSchoolPlanners = new ArrayCollection();
294.         $this->profTimes = new ArrayCollection();
295.         $this->schoolPlannerTypes = new ArrayCollection();
296.         $this->agendaElements = new ArrayCollection();
297.     }
299.     public function getId(): ?int
300.     {
301.         return $this->id;
302.     }
304.     public function getName(): ?string
305.     {
306.         return $this->name;
307.     }
309.     public function setName(string $name): static
310.     {
311.         $this->name = $name;
313.         return $this;
314.     }
316.     public function isActive(): ?bool
317.     {
318.         return $this->active;
319.     }
321.     public function setActive(bool $active): static
322.     {
323.         $this->active = $active;
325.         return $this;
326.     }
328.     /**
329.      * @return Collection<int, UserYear>
330.      */
331.     public function getUserYears(): Collection
332.     {
333.         return $this->userYears;
334.     }
336.     public function addUserYear(UserYear $userYear): static
337.     {
338.         if (!$this->userYears->contains($userYear)) {
339.             $this->userYears->add($userYear);
340.             $userYear->setYear($this);
341.         }
343.         return $this;
344.     }
346.     public function removeUserYear(UserYear $userYear): static
347.     {
348.         if ($this->userYears->removeElement($userYear)) {
349.             // set the owning side to null (unless already changed)
350.             if ($userYear->getYear() === $this) {
351.                 $userYear->setYear(null);
352.             }
353.         }
355.         return $this;
356.     }
358.     /**
359.      * @return Collection<int, StudentYear>
360.      */
361.     public function getStudentYears(): Collection
362.     {
363.         return $this->studentYears;
364.     }
366.     public function addStudentYear(StudentYear $studentYear): static
367.     {
368.         if (!$this->studentYears->contains($studentYear)) {
369.             $this->studentYears->add($studentYear);
370.             $studentYear->setYear($this);
371.         }
373.         return $this;
374.     }
376.     public function removeStudentYear(StudentYear $studentYear): static
377.     {
378.         if ($this->studentYears->removeElement($studentYear)) {
379.             // set the owning side to null (unless already changed)
380.             if ($studentYear->getYear() === $this) {
381.                 $studentYear->setYear(null);
382.             }
383.         }
385.         return $this;
386.     }
388.     /**
389.      * @return Collection<int, HomeWork>
390.      */
391.     public function getHomeWorks(): Collection
392.     {
393.         return $this->homeWorks;
394.     }
396.     public function addHomeWork(HomeWork $homeWork): static
397.     {
398.         if (!$this->homeWorks->contains($homeWork)) {
399.             $this->homeWorks->add($homeWork);
400.             $homeWork->setYear($this);
401.         }
403.         return $this;
404.     }
406.     public function removeHomeWork(HomeWork $homeWork): static
407.     {
408.         if ($this->homeWorks->removeElement($homeWork)) {
409.             // set the owning side to null (unless already changed)
410.             if ($homeWork->getYear() === $this) {
411.                 $homeWork->setYear(null);
412.             }
413.         }
415.         return $this;
416.     }
418.     /**
419.      * @return Collection<int, HomeWorkYear>
420.      */
421.     public function getHomeWorkYears(): Collection
422.     {
423.         return $this->homeWorkYears;
424.     }
426.     public function addHomeWorkYear(HomeWorkYear $homeWorkYear): static
427.     {
428.         if (!$this->homeWorkYears->contains($homeWorkYear)) {
429.             $this->homeWorkYears->add($homeWorkYear);
430.             $homeWorkYear->setYear($this);
431.         }
433.         return $this;
434.     }
436.     public function removeHomeWorkYear(HomeWorkYear $homeWorkYear): static
437.     {
438.         if ($this->homeWorkYears->removeElement($homeWorkYear)) {
439.             // set the owning side to null (unless already changed)
440.             if ($homeWorkYear->getYear() === $this) {
441.                 $homeWorkYear->setYear(null);
442.             }
443.         }
445.         return $this;
446.     }
448.     /**
449.      * @return Collection<int, Late>
450.      */
451.     public function getLates(): Collection
452.     {
453.         return $this->lates;
454.     }
456.     public function addLate(Late $late): static
457.     {
458.         if (!$this->lates->contains($late)) {
459.             $this->lates->add($late);
460.             $late->setYear($this);
461.         }
463.         return $this;
464.     }
466.     public function removeLate(Late $late): static
467.     {
468.         if ($this->lates->removeElement($late)) {
469.             // set the owning side to null (unless already changed)
470.             if ($late->getYear() === $this) {
471.                 $late->setYear(null);
472.             }
473.         }
475.         return $this;
476.     }
478.     /**
479.      * @return Collection<int, Chat>
480.      */
481.     public function getChats(): Collection
482.     {
483.         return $this->chats;
484.     }
486.     public function addChat(Chat $chat): static
487.     {
488.         if (!$this->chats->contains($chat)) {
489.             $this->chats->add($chat);
490.             $chat->setYear($this);
491.         }
492.     }
493.     /** 
494.      * @return Collection<int, Absence>
495.     */
496.     public function getAbsences(): Collection
497.     {
498.         return $this->absences;
499.     }
501.     public function addAbsence(Absence $absence): static
502.     {
503.         if (!$this->absences->contains($absence)) {
504.             $this->absences->add($absence);
505.             $absence->setYear($this);
506.         }
508.         return $this;
509.     }
511.     public function removeChat(Chat $chat): static
512.     {
513.         if ($this->chats->removeElement($chat)) {
514.             // set the owning side to null (unless already changed)
515.             if ($chat->getYear() === $this) {
516.                 $chat->setYear(null);
517.             }
518.         }
520.         return $this;
521.     }
522.     public function removeAbsence(Absence $absence): static
523.     {
524.         if ($this->absences->removeElement($absence)) {
525.             // set the owning side to null (unless already changed)
526.             if ($absence->getYear() === $this) {
527.                 $absence->setYear(null);
528.             }
529.         }
531.         return $this;
532.     }
534.     /**
535.      * @return Collection<int, Note>
536.      */
537.     public function getNotes(): Collection
538.     {
539.         return $this->notes;
540.     }
542.     public function addNote(Note $note): static
543.     {
544.         if (!$this->notes->contains($note)) {
545.             $this->notes->add($note);
546.             $note->setYear($this);
547.         }
549.         return $this;
550.     }
552.     public function removeNote(Note $note): static
553.     {
554.         if ($this->notes->removeElement($note)) {
555.             // set the owning side to null (unless already changed)
556.             if ($note->getYear() === $this) {
557.                 $note->setYear(null);
558.             }
559.         }
561.         return $this;
562.     }
564.     /**
565.      * @return Collection<int, Exams>
566.      */
567.     public function getExams(): Collection
568.     {
569.         return $this->exams;
570.     }
572.     public function addExam(Exams $exam): static
573.     {
574.         if (!$this->exams->contains($exam)) {
575.             $this->exams->add($exam);
576.             $exam->setYear($this);
577.         }
579.         return $this;
580.     }
582.     public function removeExam(Exams $exam): static
583.     {
584.         if ($this->exams->removeElement($exam)) {
585.             // set the owning side to null (unless already changed)
586.             if ($exam->getYear() === $this) {
587.                 $exam->setYear(null);
588.             }
589.         }
591.         return $this;
592.     }
594.     /**
595.      * @return Collection<int, DocInfo>
596.      */
597.     public function getDocInfos(): Collection
598.     {
599.         return $this->docInfos;
600.     }
602.     public function addDocInfo(DocInfo $docInfo): static
603.     {
604.         if (!$this->docInfos->contains($docInfo)) {
605.             $this->docInfos->add($docInfo);
606.             $docInfo->setYear($this);
607.         }
609.         return $this;
610.     }
612.     public function removeDocInfo(DocInfo $docInfo): static
613.     {
614.         if ($this->docInfos->removeElement($docInfo)) {
615.             // set the owning side to null (unless already changed)
616.             if ($docInfo->getYear() === $this) {
617.                 $docInfo->setYear(null);
618.             }
619.         }
621.         return $this;
622.     }
624.     public function getAuthor(): ?User
625.     {
626.         return $this->author;
627.     }
629.     public function setAuthor(?User $author): static
630.     {
631.         $this->author = $author;
633.         return $this;
634.     }
635.     
636.     /**
637.      * @return Collection<int, Punish>
638.      */
639.     public function getPunishes(): Collection
640.     {
641.         return $this->punishes;
642.     }
644.     public function addPunish(Punish $punish): static
645.     {
646.         if (!$this->punishes->contains($punish)) {
647.             $this->punishes->add($punish);
648.             $punish->setYear($this);
649.         }
651.         return $this;
652.     }
653.     public function removePunish(Punish $punish): static
654.     {
655.         if ($this->punishes->removeElement($punish)) {
656.             // set the owning side to null (unless already changed)
657.             if ($punish->getYear() === $this) {
658.                 $punish->setYear(null);
659.             }
660.         }
662.         return $this;
663.     }
665.     public function getEditor(): ?User
666.     {
667.         return $this->editor;
668.     }
670.     public function setEditor(?User $editor): static
671.     {
672.         $this->editor = $editor;
674.         return $this;
675.     }
677.     /**
678.      * @return Collection<int, Discussion>
679.      */
680.     public function getDiscussions(): Collection
681.     {
682.         return $this->discussions;
683.     }
685.     public function addDiscussion(Discussion $discussion): static
686.     {
687.         if (!$this->discussions->contains($discussion)) {
688.             $this->discussions->add($discussion);
689.             $discussion->setYear($this);
690.         }
692.         return $this;
693.     }
695.     public function removeDiscussion(Discussion $discussion): static
696.     {
697.         if ($this->discussions->removeElement($discussion)) {
698.             // set the owning side to null (unless already changed)
699.             if ($discussion->getYear() === $this) {
700.                 $discussion->setYear(null);
701.             }
702.         }
704.         return $this;
705.     }
707.     /**
708.      * @return Collection<int, DiscussionClass>
709.      */
710.     public function getDiscussionClasses(): Collection
711.     {
712.         return $this->discussionClasses;
713.     }
715.     public function addDiscussionClass(DiscussionClass $discussionClass): static
716.     {
717.         if (!$this->discussionClasses->contains($discussionClass)) {
718.             $this->discussionClasses->add($discussionClass);
719.             $discussionClass->setYear($this);
720.         }
722.         return $this;
723.     }
725.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
726.     {
727.         if ($this->discussionClasses->removeElement($discussionClass)) {
728.             // set the owning side to null (unless already changed)
729.             if ($discussionClass->getYear() === $this) {
730.                 $discussionClass->setYear(null);
731.             }
732.         }
734.         return $this;
735.     }
737.     /**
738.      * @return Collection<int, Agenda>
739.      */
740.     public function getAgendas(): Collection
741.     {
742.         return $this->agendas;
743.     }
745.     public function addAgenda(Agenda $agenda): static
746.     {
747.         if (!$this->agendas->contains($agenda)) {
748.             $this->agendas->add($agenda);
749.             $agenda->setYear($this);
750.         }
752.         return $this;
753.     }
755.     public function removeAgenda(Agenda $agenda): static
756.     {
757.         if ($this->agendas->removeElement($agenda)) {
758.             // set the owning side to null (unless already changed)
759.             if ($agenda->getYear() === $this) {
760.                 $agenda->setYear(null);
761.             }
762.         }
764.         return $this;
765.     }
767.     /**
768.      * @return Collection<int, ExamAgenda>
769.      */
770.     public function getExamAgendas(): Collection
771.     {
772.         return $this->examAgendas;
773.     }
775.     public function addExamAgenda(ExamAgenda $examAgenda): static
776.     {
777.         if (!$this->examAgendas->contains($examAgenda)) {
778.             $this->examAgendas->add($examAgenda);
779.             $examAgenda->setYear($this);
780.         }
782.         return $this;
783.     }
785.     public function removeExamAgenda(ExamAgenda $examAgenda): static
786.     {
787.         if ($this->examAgendas->removeElement($examAgenda)) {
788.             // set the owning side to null (unless already changed)
789.             if ($examAgenda->getYear() === $this) {
790.                 $examAgenda->setYear(null);
791.             }
792.         }
794.         return $this;
795.     }
797.     /**
798.      * @return Collection<int, Quarter>
799.      */
800.     public function getQuarters(): Collection
801.     {
802.         return $this->quarters;
803.     }
805.     public function addQuarter(Quarter $quarter): static
806.     {
807.         if (!$this->quarters->contains($quarter)) {
808.             $this->quarters->add($quarter);
809.             $quarter->setYear($this);
810.         }
812.         return $this;
813.     }
815.     public function removeQuarter(Quarter $quarter): static
816.     {
817.         if ($this->quarters->removeElement($quarter)) {
818.             // set the owning side to null (unless already changed)
819.             if ($quarter->getYear() === $this) {
820.                 $quarter->setYear(null);
821.             }
822.         }
824.         return $this;
825.     }
827.     /**
828.      * @return Collection<int, GlobalQuarter>
829.      */
830.     public function getGlobalQuarters(): Collection
831.     {
832.         return $this->globalQuarters;
833.     }
835.     public function addGlobalQuarter(GlobalQuarter $globalQuarter): static
836.     {
837.         if (!$this->globalQuarters->contains($globalQuarter)) {
838.             $this->globalQuarters->add($globalQuarter);
839.             $globalQuarter->setYear($this);
840.         }
841.         return $this;
842.     }
844.     public function removeGlobalQuarter(GlobalQuarter $globalQuarter): static
845.     {
846.         if ($this->globalQuarters->removeElement($globalQuarter)) {
847.             // set the owning side to null (unless already changed)
848.             if ($globalQuarter->getYear() === $this) {
849.                 $globalQuarter->setYear(null);
850.             }
851.         }
853.         return $this;
854.     }
856.     /**
857.      * @return Collection<int, LocalAccount>
858.      */
859.     public function getLocalAccounts(): Collection
860.     {
861.         return $this->localAccounts;
862.     }
864.     public function addLocalAccount(LocalAccount $localAccount): static
865.     {
866.         if (!$this->localAccounts->contains($localAccount)) {
867.             $this->localAccounts->add($localAccount);
868.             $localAccount->setYear($this);
869.         }
871.         return $this;
872.     }
874.     public function removeLocalAccount(LocalAccount $localAccount): static
875.     {
876.         if ($this->localAccounts->removeElement($localAccount)) {
877.             // set the owning side to null (unless already changed)
878.             if ($localAccount->getYear() === $this) {
879.                 $localAccount->setYear(null);
880.             }
881.         }
883.         return $this;
884.     }
886.     /**
887.      * @return Collection<int, Appreciation>
888.      */
889.     public function getAppreciations(): Collection
890.     {
891.         return $this->appreciations;
892.     }
894.     public function addAppreciation(Appreciation $appreciation): static
895.     {
896.         if (!$this->appreciations->contains($appreciation)) {
897.             $this->appreciations->add($appreciation);
898.             $appreciation->setYear($this);
899.         }
901.         return $this;
902.     }
904.     public function removeAppreciation(Appreciation $appreciation): static
905.     {
906.         if ($this->appreciations->removeElement($appreciation)) {
907.             // set the owning side to null (unless already changed)
908.             if ($appreciation->getYear() === $this) {
909.                 $appreciation->setYear(null);
910.             }
911.         }
913.         return $this;
914.     }
916.     /**
917.      * @return Collection<int, DisciplineWarning>
918.      */
919.     public function getDisciplineWarnings(): Collection
920.     {
921.         return $this->disciplineWarnings;
922.     }
924.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
925.     {
926.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
927.             $this->disciplineWarnings->add($disciplineWarning);
928.             $disciplineWarning->setYear($this);
929.         }
931.         return $this;
932.     }
934.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
935.     {
936.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
937.             // set the owning side to null (unless already changed)
938.             if ($disciplineWarning->getYear() === $this) {
939.                 $disciplineWarning->setYear(null);
940.             }
941.         }
943.         return $this;
944.     }
946.     /**
947.      * @return Collection<int, DisciplineBlame>
948.      */
949.     public function getDisciplineBlames(): Collection
950.     {
951.         return $this->disciplineBlames;
952.     }
954.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
955.     {
956.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
957.             $this->disciplineBlames->add($disciplineBlame);
958.             $disciplineBlame->setYear($this);
959.         }
961.         return $this;
962.     }
964.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
965.     {
966.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
967.             // set the owning side to null (unless already changed)
968.             if ($disciplineBlame->getYear() === $this) {
969.                 $disciplineBlame->setYear(null);
970.             }
971.         }
973.         return $this;
974.     }
976.     /**
977.      * @return Collection<int, DisciplineExclusion>
978.      */
979.     public function getDisciplineExclusions(): Collection
980.     {
981.         return $this->disciplineExclusions;
982.     }
984.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
985.     {
986.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
987.             $this->disciplineExclusions->add($disciplineExclusion);
988.             $disciplineExclusion->setYear($this);
989.         }
991.         return $this;
992.     }
994.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
995.     {
996.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
997.             // set the owning side to null (unless already changed)
998.             if ($disciplineExclusion->getYear() === $this) {
999.                 $disciplineExclusion->setYear(null);
1000.             }
1001.         }
1003.         return $this;
1004.     }
1006.     /**
1007.      * @return Collection<int, ParentNote>
1008.      */
1009.     public function getParentNotes(): Collection
1010.     {
1011.         return $this->parentNotes;
1012.     }
1014.     public function addParentNote(ParentNote $parentNote): static
1015.     {
1016.         if (!$this->parentNotes->contains($parentNote)) {
1017.             $this->parentNotes->add($parentNote);
1018.             $parentNote->setYear($this);
1019.         }
1021.         return $this;
1022.     }
1024.     public function removeParentNote(ParentNote $parentNote): static
1025.     {
1026.         if ($this->parentNotes->removeElement($parentNote)) {
1027.             // set the owning side to null (unless already changed)
1028.             if ($parentNote->getYear() === $this) {
1029.                 $parentNote->setYear(null);
1030.             }
1031.         }
1033.         return $this;
1034.     }
1036.     /**
1037.      * @return Collection<int, JustifyAbsence>
1038.      */
1039.     public function getJustifyAbsences(): Collection
1040.     {
1041.         return $this->justifyAbsences;
1042.     }
1044.     public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static
1045.     {
1046.         if (!$this->justifyAbsences->contains($justifyAbsence)) {
1047.             $this->justifyAbsences->add($justifyAbsence);
1048.             $justifyAbsence->setYear($this);
1049.         }
1051.         return $this;
1052.     }
1054.     public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static
1055.     {
1056.         if ($this->justifyAbsences->removeElement($justifyAbsence)) {
1057.             // set the owning side to null (unless already changed)
1058.             if ($justifyAbsence->getYear() === $this) {
1059.                 $justifyAbsence->setYear(null);
1060.             }
1061.         }
1063.         return $this;
1064.     }
1066.     /**
1067.      * @return Collection<int, Subject>
1068.      */
1069.     public function getSubjects(): Collection
1070.     {
1071.         return $this->subjects;
1072.     }
1074.     public function addSubject(Subject $subject): static
1075.     {
1076.         if (!$this->subjects->contains($subject)) {
1077.             $this->subjects->add($subject);
1078.             $subject->setYear($this);
1079.         }
1081.         return $this;
1082.     }
1084.     public function removeSubject(Subject $subject): static
1085.     {
1086.         if ($this->subjects->removeElement($subject)) {
1087.             // set the owning side to null (unless already changed)
1088.             if ($subject->getYear() === $this) {
1089.                 $subject->setYear(null);
1090.             }
1091.         }
1093.         return $this;
1094.     }
1096.     /**
1097.      * @return Collection<int, AbsenceRetainedConfig>
1098.      */
1099.     public function getAbsenceRetainedConfigs(): Collection
1100.     {
1101.         return $this->absenceRetainedConfigs;
1102.     }
1104.     public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
1105.     {
1106.         if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) {
1107.             $this->absenceRetainedConfigs->add($absenceRetainedConfig);
1108.             $absenceRetainedConfig->setYear($this);
1109.         }
1111.         return $this;
1112.     }
1114.     public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
1115.     {
1116.         if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) {
1117.             // set the owning side to null (unless already changed)
1118.             if ($absenceRetainedConfig->getYear() === $this) {
1119.                 $absenceRetainedConfig->setYear(null);
1120.             }
1121.         }
1123.         return $this;
1124.     }
1126.     /**
1127.      * @return Collection<int, AbsenceWarningConfig>
1128.      */
1129.     public function getAbsenceWarningConfigs(): Collection
1130.     {
1131.         return $this->absenceWarningConfigs;
1132.     }
1134.     public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
1135.     {
1136.         if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) {
1137.             $this->absenceWarningConfigs->add($absenceWarningConfig);
1138.             $absenceWarningConfig->setYear($this);
1139.         }
1141.         return $this;
1142.     }
1144.     public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
1145.     {
1146.         if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) {
1147.             // set the owning side to null (unless already changed)
1148.             if ($absenceWarningConfig->getYear() === $this) {
1149.                 $absenceWarningConfig->setYear(null);
1150.             }
1151.         }
1153.         return $this;
1154.     }
1156.     /**
1157.      * @return Collection<int, AbsenceExclusionConfig>
1158.      */
1159.     public function getAbsenceExclusionConfigs(): Collection
1160.     {
1161.         return $this->absenceExclusionConfigs;
1162.     }
1164.     public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
1165.     {
1166.         if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) {
1167.             $this->absenceExclusionConfigs->add($absenceExclusionConfig);
1168.             $absenceExclusionConfig->setYear($this);
1169.         }
1171.         return $this;
1172.     }
1174.     public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
1175.     {
1176.         if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) {
1177.             // set the owning side to null (unless already changed)
1178.             if ($absenceExclusionConfig->getYear() === $this) {
1179.                 $absenceExclusionConfig->setYear(null);
1180.             }
1181.         }
1183.         return $this;
1184.     }
1186.     /**
1187.      * @return Collection<int, AbsenceBlameConfig>
1188.      */
1189.     public function getAbsenceBlameConfigs(): Collection
1190.     {
1191.         return $this->absenceBlameConfigs;
1192.     }
1194.     public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
1195.     {
1196.         if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) {
1197.             $this->absenceBlameConfigs->add($absenceBlameConfig);
1198.             $absenceBlameConfig->setYear($this);
1199.         }
1201.         return $this;
1202.     }
1204.     public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
1205.     {
1206.         if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) {
1207.             // set the owning side to null (unless already changed)
1208.             if ($absenceBlameConfig->getYear() === $this) {
1209.                 $absenceBlameConfig->setYear(null);
1210.             }
1211.         }
1213.         return $this;
1214.     }
1216.     /**
1217.      * @return Collection<int, DisciplineRetained>
1218.      */
1219.     public function getDisciplineRetaineds(): Collection
1220.     {
1221.         return $this->disciplineRetaineds;
1222.     }
1224.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
1225.     {
1226.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
1227.             $this->disciplineRetaineds->add($disciplineRetained);
1228.             $disciplineRetained->setYear($this);
1229.         }
1231.         return $this;
1232.     }
1234.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
1235.     {
1236.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
1237.             // set the owning side to null (unless already changed)
1238.             if ($disciplineRetained->getYear() === $this) {
1239.                 $disciplineRetained->setYear(null);
1240.             }
1241.         }
1243.         return $this;
1244.     }
1246.     /**
1247.      * @return Collection<int, DefinitiveExclusion>
1248.      */
1249.     public function getDefinitiveExclusions(): Collection
1250.     {
1251.         return $this->definitiveExclusions;
1252.     }
1254.     public function addDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
1255.     {
1256.         if (!$this->definitiveExclusions->contains($definitiveExclusion)) {
1257.             $this->definitiveExclusions->add($definitiveExclusion);
1258.             $definitiveExclusion->setYear($this);
1259.         }
1261.         return $this;
1262.     }
1264.     public function removeDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
1265.     {
1266.         if ($this->definitiveExclusions->removeElement($definitiveExclusion)) {
1267.             // set the owning side to null (unless already changed)
1268.             if ($definitiveExclusion->getYear() === $this) {
1269.                 $definitiveExclusion->setYear(null);
1270.             }
1271.         }
1273.         return $this;
1274.     }
1276.     /**
1277.      * @return Collection<int, DisciplineConcile>
1278.      */
1279.     public function getDisciplineConciles(): Collection
1280.     {
1281.         return $this->disciplineConciles;
1282.     }
1284.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
1285.     {
1286.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
1287.             $this->disciplineConciles->add($disciplineConcile);
1288.             $disciplineConcile->setYear($this);
1289.         }
1291.         return $this;
1292.     }
1294.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
1295.     {
1296.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
1297.             // set the owning side to null (unless already changed)
1298.             if ($disciplineConcile->getYear() === $this) {
1299.                 $disciplineConcile->setYear(null);
1300.             }
1301.         }
1303.         return $this;
1304.     }
1306.     /**
1307.      * @return Collection<int, AbsenceDisciplineConcileConfig>
1308.      */
1309.     public function getAbsenceDisciplineConcileConfigs(): Collection
1310.     {
1311.         return $this->absenceDisciplineConcileConfigs;
1312.     }
1314.     public function addAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
1315.     {
1316.         if (!$this->absenceDisciplineConcileConfigs->contains($absenceDisciplineConcileConfig)) {
1317.             $this->absenceDisciplineConcileConfigs->add($absenceDisciplineConcileConfig);
1318.             $absenceDisciplineConcileConfig->setYear($this);
1319.         }
1321.         return $this;
1322.     }
1324.     public function removeAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
1325.     {
1326.         if ($this->absenceDisciplineConcileConfigs->removeElement($absenceDisciplineConcileConfig)) {
1327.             // set the owning side to null (unless already changed)
1328.             if ($absenceDisciplineConcileConfig->getYear() === $this) {
1329.                 $absenceDisciplineConcileConfig->setYear(null);
1330.             }
1331.         }
1333.         return $this;
1334.     }
1336.     /**
1337.      * @return Collection<int, WarningBlameConfig>
1338.      */
1339.     public function getWarningBlameConfigs(): Collection
1340.     {
1341.         return $this->warningBlameConfigs;
1342.     }
1344.     public function addWarningBlameConfig(WarningBlameConfig $warningBlameConfig): static
1345.     {
1346.         if (!$this->warningBlameConfigs->contains($warningBlameConfig)) {
1347.             $this->warningBlameConfigs->add($warningBlameConfig);
1348.             $warningBlameConfig->setYear($this);
1349.         }
1351.         return $this;
1352.     }
1354.     public function removeWarningBlameConfig(WarningBlameConfig $warningBlameConfig): static
1355.     {
1356.         if ($this->warningBlameConfigs->removeElement($warningBlameConfig)) {
1357.             // set the owning side to null (unless already changed)
1358.             if ($warningBlameConfig->getYear() === $this) {
1359.                 $warningBlameConfig->setYear(null);
1360.             }
1361.         }
1363.         return $this;
1364.     }
1366.     /**
1367.      * @return Collection<int, WarningDefinitiveExlusionConfig>
1368.      */
1369.     public function getWarningDefinitiveExlusionConfigs(): Collection
1370.     {
1371.         return $this->warningDefinitiveExlusionConfigs;
1372.     }
1374.     public function addWarningDefinitiveExlusionConfig(WarningDefinitiveExlusionConfig $warningDefinitiveExlusionConfig): static
1375.     {
1376.         if (!$this->warningDefinitiveExlusionConfigs->contains($warningDefinitiveExlusionConfig)) {
1377.             $this->warningDefinitiveExlusionConfigs->add($warningDefinitiveExlusionConfig);
1378.             $warningDefinitiveExlusionConfig->setYear($this);
1379.         }
1381.         return $this;
1382.     }
1384.     public function removeWarningDefinitiveExlusionConfig(WarningDefinitiveExlusionConfig $warningDefinitiveExlusionConfig): static
1385.     {
1386.         if ($this->warningDefinitiveExlusionConfigs->removeElement($warningDefinitiveExlusionConfig)) {
1387.             // set the owning side to null (unless already changed)
1388.             if ($warningDefinitiveExlusionConfig->getYear() === $this) {
1389.                 $warningDefinitiveExlusionConfig->setYear(null);
1390.             }
1391.         }
1393.         return $this;
1394.     }
1396.     /**
1397.      * @return Collection<int, PrimaryParentNote>
1398.      */
1399.     public function getPrimaryParentNotes(): Collection
1400.     {
1401.         return $this->primaryParentNotes;
1402.     }
1404.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
1405.     {
1406.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
1407.             $this->primaryParentNotes->add($primaryParentNote);
1408.             $primaryParentNote->setYear($this);
1409.         }
1411.         return $this;
1412.     }
1414.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
1415.     {
1416.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
1417.             // set the owning side to null (unless already changed)
1418.             if ($primaryParentNote->getYear() === $this) {
1419.                 $primaryParentNote->setYear(null);
1420.             }
1421.         }
1423.         return $this;
1424.     }
1426.     /**
1427.      * @return Collection<int, PrimaryNote>
1428.      */
1429.     public function getPrimaryNotes(): Collection
1430.     {
1431.         return $this->primaryNotes;
1432.     }
1434.     public function addPrimaryNote(PrimaryNote $primaryNote): static
1435.     {
1436.         if (!$this->primaryNotes->contains($primaryNote)) {
1437.             $this->primaryNotes->add($primaryNote);
1438.             $primaryNote->setYear($this);
1439.         }
1441.         return $this;
1442.     }
1444.     public function removePrimaryNote(PrimaryNote $primaryNote): static
1445.     {
1446.         if ($this->primaryNotes->removeElement($primaryNote)) {
1447.             // set the owning side to null (unless already changed)
1448.             if ($primaryNote->getYear() === $this) {
1449.                 $primaryNote->setYear(null);
1450.             }
1451.         }
1453.         return $this;
1454.     }
1456.     /**
1457.      * @return Collection<int, VerbalProcessCategory>
1458.      */
1459.     public function getVerbalProcessCategories(): Collection
1460.     {
1461.         return $this->verbalProcessCategories;
1462.     }
1464.     public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
1465.     {
1466.         if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) {
1467.             $this->verbalProcessCategories->add($verbalProcessCategory);
1468.             $verbalProcessCategory->setYear($this);
1469.         }
1471.         return $this;
1472.     }
1474.     public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
1475.     {
1476.         if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) {
1477.             // set the owning side to null (unless already changed)
1478.             if ($verbalProcessCategory->getYear() === $this) {
1479.                 $verbalProcessCategory->setYear(null);
1480.             }
1481.         }
1483.         return $this;
1484.     }
1486.     /**
1487.      * @return Collection<int, GlobalDisciplineConfig>
1488.      */
1489.     public function getGlobalDisciplineConfigs(): Collection
1490.     {
1491.         return $this->globalDisciplineConfigs;
1492.     }
1494.     public function addGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static
1495.     {
1496.         if (!$this->globalDisciplineConfigs->contains($globalDisciplineConfig)) {
1497.             $this->globalDisciplineConfigs->add($globalDisciplineConfig);
1498.             $globalDisciplineConfig->setYear($this);
1499.         }
1501.         return $this;
1502.     }
1504.     public function removeGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static
1505.     {
1506.         if ($this->globalDisciplineConfigs->removeElement($globalDisciplineConfig)) {
1507.             // set the owning side to null (unless already changed)
1508.             if ($globalDisciplineConfig->getYear() === $this) {
1509.                 $globalDisciplineConfig->setYear(null);
1510.             }
1511.         }
1513.         return $this;
1514.     }
1516.     /**
1517.      * @return Collection<int, DisciplinePunish>
1518.      */
1519.     public function getDisciplinePunishes(): Collection
1520.     {
1521.         return $this->disciplinePunishes;
1522.     }
1524.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
1525.     {
1526.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
1527.             $this->disciplinePunishes->add($disciplinePunish);
1528.             $disciplinePunish->setYear($this);
1529.         }
1531.         return $this;
1532.     }
1534.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
1535.     {
1536.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
1537.             // set the owning side to null (unless already changed)
1538.             if ($disciplinePunish->getYear() === $this) {
1539.                 $disciplinePunish->setYear(null);
1540.             }
1541.         }
1543.         return $this;
1544.     }
1546.     /**
1547.      * @return Collection<int, GlobalDisciplineEnabledConfig>
1548.      */
1549.     public function getGlobalDisciplineEnabledConfigs(): Collection
1550.     {
1551.         return $this->globalDisciplineEnabledConfigs;
1552.     }
1554.     public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
1555.     {
1556.         if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) {
1557.             $this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig);
1558.             $globalDisciplineEnabledConfig->setYear($this);
1559.         }
1561.         return $this;
1562.     }
1564.     public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
1565.     {
1566.         if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) {
1567.             // set the owning side to null (unless already changed)
1568.             if ($globalDisciplineEnabledConfig->getYear() === $this) {
1569.                 $globalDisciplineEnabledConfig->setYear(null);
1570.             }
1571.         }
1573.         return $this;
1574.     }
1576.     /**
1577.      * @return Collection<int, BlamePunishConfig>
1578.      */
1579.     public function getBlamePunishConfigs(): Collection
1580.     {
1581.         return $this->blamePunishConfigs;
1582.     }
1584.     public function addBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static
1585.     {
1586.         if (!$this->blamePunishConfigs->contains($blamePunishConfig)) {
1587.             $this->blamePunishConfigs->add($blamePunishConfig);
1588.             $blamePunishConfig->setYear($this);
1589.         }
1591.         return $this;
1592.     }
1594.     public function removeBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static
1595.     {
1596.         if ($this->blamePunishConfigs->removeElement($blamePunishConfig)) {
1597.             // set the owning side to null (unless already changed)
1598.             if ($blamePunishConfig->getYear() === $this) {
1599.                 $blamePunishConfig->setYear(null);
1600.             }
1601.         }
1603.         return $this;
1604.     }
1606.     /**
1607.      * @return Collection<int, AbsencePunishConfig>
1608.      */
1609.     public function getAbsencePunishConfigs(): Collection
1610.     {
1611.         return $this->absencePunishConfigs;
1612.     }
1614.     public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
1615.     {
1616.         if (!$this->absencePunishConfigs->contains($absencePunishConfig)) {
1617.             $this->absencePunishConfigs->add($absencePunishConfig);
1618.             $absencePunishConfig->setYear($this);
1619.         }
1621.         return $this;
1622.     }
1624.     public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
1625.     {
1626.         if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) {
1627.             // set the owning side to null (unless already changed)
1628.             if ($absencePunishConfig->getYear() === $this) {
1629.                 $absencePunishConfig->setYear(null);
1630.             }
1631.         }
1633.         return $this;
1634.     }
1636.     /**
1637.      * @return Collection<int, WarningPunishConfig>
1638.      */
1639.     public function getWarningPunishConfigs(): Collection
1640.     {
1641.         return $this->warningPunishConfigs;
1642.     }
1644.     public function addWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static
1645.     {
1646.         if (!$this->warningPunishConfigs->contains($warningPunishConfig)) {
1647.             $this->warningPunishConfigs->add($warningPunishConfig);
1648.             $warningPunishConfig->setYear($this);
1649.         }
1651.         return $this;
1652.     }
1654.     public function removeWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static
1655.     {
1656.         if ($this->warningPunishConfigs->removeElement($warningPunishConfig)) {
1657.             // set the owning side to null (unless already changed)
1658.             if ($warningPunishConfig->getYear() === $this) {
1659.                 $warningPunishConfig->setYear(null);
1660.             }
1661.         }
1663.         return $this;
1664.     }
1666.     /**
1667.      * @return Collection<int, PunishRetainedConfig>
1668.      */
1669.     public function getPunishRetainedConfigs(): Collection
1670.     {
1671.         return $this->punishRetainedConfigs;
1672.     }
1674.     public function addPunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static
1675.     {
1676.         if (!$this->punishRetainedConfigs->contains($punishRetainedConfig)) {
1677.             $this->punishRetainedConfigs->add($punishRetainedConfig);
1678.             $punishRetainedConfig->setYear($this);
1679.         }
1681.         return $this;
1682.     }
1684.     public function removePunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static
1685.     {
1686.         if ($this->punishRetainedConfigs->removeElement($punishRetainedConfig)) {
1687.             // set the owning side to null (unless already changed)
1688.             if ($punishRetainedConfig->getYear() === $this) {
1689.                 $punishRetainedConfig->setYear(null);
1690.             }
1691.         }
1693.         return $this;
1694.     }
1696.     /**
1697.      * @return Collection<int, PunishWarningConfig>
1698.      */
1699.     public function getPunishWarningConfigs(): Collection
1700.     {
1701.         return $this->punishWarningConfigs;
1702.     }
1704.     public function addPunishWarningConfig(PunishWarningConfig $punishWarningConfig): static
1705.     {
1706.         if (!$this->punishWarningConfigs->contains($punishWarningConfig)) {
1707.             $this->punishWarningConfigs->add($punishWarningConfig);
1708.             $punishWarningConfig->setYear($this);
1709.         }
1711.         return $this;
1712.     }
1714.     public function removePunishWarningConfig(PunishWarningConfig $punishWarningConfig): static
1715.     {
1716.         if ($this->punishWarningConfigs->removeElement($punishWarningConfig)) {
1717.             // set the owning side to null (unless already changed)
1718.             if ($punishWarningConfig->getYear() === $this) {
1719.                 $punishWarningConfig->setYear(null);
1720.             }
1721.         }
1723.         return $this;
1724.     }
1726.     /**
1727.      * @return Collection<int, PunishBlameConfig>
1728.      */
1729.     public function getPunishBlameConfigs(): Collection
1730.     {
1731.         return $this->punishBlameConfigs;
1732.     }
1734.     public function addPunishBlameConfig(PunishBlameConfig $punishBlameConfig): static
1735.     {
1736.         if (!$this->punishBlameConfigs->contains($punishBlameConfig)) {
1737.             $this->punishBlameConfigs->add($punishBlameConfig);
1738.             $punishBlameConfig->setYear($this);
1739.         }
1741.         return $this;
1742.     }
1744.     public function removePunishBlameConfig(PunishBlameConfig $punishBlameConfig): static
1745.     {
1746.         if ($this->punishBlameConfigs->removeElement($punishBlameConfig)) {
1747.             // set the owning side to null (unless already changed)
1748.             if ($punishBlameConfig->getYear() === $this) {
1749.                 $punishBlameConfig->setYear(null);
1750.             }
1751.         }
1753.         return $this;
1754.     }
1756.     /**
1757.      * @return Collection<int, PunishExclusionConfig>
1758.      */
1759.     public function getPunishExclusionConfigs(): Collection
1760.     {
1761.         return $this->punishExclusionConfigs;
1762.     }
1764.     public function addPunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static
1765.     {
1766.         if (!$this->punishExclusionConfigs->contains($punishExclusionConfig)) {
1767.             $this->punishExclusionConfigs->add($punishExclusionConfig);
1768.             $punishExclusionConfig->setYear($this);
1769.         }
1771.         return $this;
1772.     }
1774.     public function removePunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static
1775.     {
1776.         if ($this->punishExclusionConfigs->removeElement($punishExclusionConfig)) {
1777.             // set the owning side to null (unless already changed)
1778.             if ($punishExclusionConfig->getYear() === $this) {
1779.                 $punishExclusionConfig->setYear(null);
1780.             }
1781.         }
1783.         return $this;
1784.     }
1786.     public function getNameEn(): ?string
1787.     {
1788.         return $this->nameEn;
1789.     }
1791.     public function setNameEn(string $nameEn): static
1792.     {
1793.         $this->nameEn = $nameEn;
1795.         return $this;
1796.     }
1798.     /**
1799.      * @return Collection<int, SchoolYearInfos>
1800.      */
1801.     public function getSchoolYearInfos(): Collection
1802.     {
1803.         return $this->schoolYearInfos;
1804.     }
1806.     public function addSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static
1807.     {
1808.         if (!$this->schoolYearInfos->contains($schoolYearInfo)) {
1809.             $this->schoolYearInfos->add($schoolYearInfo);
1810.             $schoolYearInfo->setYear($this);
1811.         }
1813.         return $this;
1814.     }
1816.     public function removeSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static
1817.     {
1818.         if ($this->schoolYearInfos->removeElement($schoolYearInfo)) {
1819.             // set the owning side to null (unless already changed)
1820.             if ($schoolYearInfo->getYear() === $this) {
1821.                 $schoolYearInfo->setYear(null);
1822.             }
1823.         }
1825.         return $this;
1826.     }
1828.     /**
1829.      * @return Collection<int, Blame>
1830.      */
1831.     public function getBlames(): Collection
1832.     {
1833.         return $this->blames;
1834.     }
1836.     public function addBlame(Blame $blame): static
1837.     {
1838.         if (!$this->blames->contains($blame)) {
1839.             $this->blames->add($blame);
1840.             $blame->setYear($this);
1841.         }
1843.         return $this;
1844.     }
1846.     public function removeBlame(Blame $blame): static
1847.     {
1848.         if ($this->blames->removeElement($blame)) {
1849.             // set the owning side to null (unless already changed)
1850.             if ($blame->getYear() === $this) {
1851.                 $blame->setYear(null);
1852.             }
1853.         }
1855.         return $this;
1856.     }
1858.     /**
1859.      * @return Collection<int, Warning>
1860.      */
1861.     public function getWarnings(): Collection
1862.     {
1863.         return $this->warnings;
1864.     }
1866.     public function addWarning(Warning $warning): static
1867.     {
1868.         if (!$this->warnings->contains($warning)) {
1869.             $this->warnings->add($warning);
1870.             $warning->setYear($this);
1871.         }
1873.         return $this;
1874.     }
1876.     public function removeWarning(Warning $warning): static
1877.     {
1878.         if ($this->warnings->removeElement($warning)) {
1879.             // set the owning side to null (unless already changed)
1880.             if ($warning->getYear() === $this) {
1881.                 $warning->setYear(null);
1882.             }
1883.         }
1885.         return $this;
1886.     }
1888.     /**
1889.      * @return Collection<int, Retained>
1890.      */
1891.     public function getRetaineds(): Collection
1892.     {
1893.         return $this->retaineds;
1894.     }
1896.     public function addRetained(Retained $retained): static
1897.     {
1898.         if (!$this->retaineds->contains($retained)) {
1899.             $this->retaineds->add($retained);
1900.             $retained->setYear($this);
1901.         }
1903.         return $this;
1904.     }
1906.     public function removeRetained(Retained $retained): static
1907.     {
1908.         if ($this->retaineds->removeElement($retained)) {
1909.             // set the owning side to null (unless already changed)
1910.             if ($retained->getYear() === $this) {
1911.                 $retained->setYear(null);
1912.             }
1913.         }
1915.         return $this;
1916.     }
1918.     /**
1919.      * @return Collection<int, HonnorTableLimitMoy>
1920.      */
1921.     public function getHonnorTableLimitMoys(): Collection
1922.     {
1923.         return $this->honnorTableLimitMoys;
1924.     }
1926.     public function addHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static
1927.     {
1928.         if (!$this->honnorTableLimitMoys->contains($honnorTableLimitMoy)) {
1929.             $this->honnorTableLimitMoys->add($honnorTableLimitMoy);
1930.             $honnorTableLimitMoy->setYear($this);
1931.         }
1933.         return $this;
1934.     }
1936.     public function removeHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static
1937.     {
1938.         if ($this->honnorTableLimitMoys->removeElement($honnorTableLimitMoy)) {
1939.             // set the owning side to null (unless already changed)
1940.             if ($honnorTableLimitMoy->getYear() === $this) {
1941.                 $honnorTableLimitMoy->setYear(null);
1942.             }
1943.         }
1945.         return $this;
1946.     }
1948.     /**
1949.      * @return Collection<int, News>
1950.      */
1951.     public function getNews(): Collection
1952.     {
1953.         return $this->news;
1954.     }
1956.     public function addNews(News $news): static
1957.     {
1958.         if (!$this->news->contains($news)) {
1959.             $this->news->add($news);
1960.             $news->setYear($this);
1961.         }
1963.         return $this;
1964.     }
1966.     public function removeNews(News $news): static
1967.     {
1968.         if ($this->news->removeElement($news)) {
1969.             // set the owning side to null (unless already changed)
1970.             if ($news->getYear() === $this) {
1971.                 $news->setYear(null);
1972.             }
1973.         }
1975.         return $this;
1976.     }
1978.     /**
1979.      * @return Collection<int, Event>
1980.      */
1981.     public function getEvents(): Collection
1982.     {
1983.         return $this->events;
1984.     }
1986.     public function addEvent(Event $event): static
1987.     {
1988.         if (!$this->events->contains($event)) {
1989.             $this->events->add($event);
1990.             $event->setYear($this);
1991.         }
1993.         return $this;
1994.     }
1996.     public function removeEvent(Event $event): static
1997.     {
1998.         if ($this->events->removeElement($event)) {
1999.             // set the owning side to null (unless already changed)
2000.             if ($event->getYear() === $this) {
2001.                 $event->setYear(null);
2002.             }
2003.         }
2005.         return $this;
2006.     }
2008.     /**
2009.      * @return Collection<int, AdmissionLimit>
2010.      */
2011.     public function getAdmissionLimits(): Collection
2012.     {
2013.         return $this->admissionLimits;
2014.     }
2016.     public function addAdmissionLimit(AdmissionLimit $admissionLimit): static
2017.     {
2018.         if (!$this->admissionLimits->contains($admissionLimit)) {
2019.             $this->admissionLimits->add($admissionLimit);
2020.             $admissionLimit->setYear($this);
2021.         }
2023.         return $this;
2024.     }
2026.     public function removeAdmissionLimit(AdmissionLimit $admissionLimit): static
2027.     {
2028.         if ($this->admissionLimits->removeElement($admissionLimit)) {
2029.             // set the owning side to null (unless already changed)
2030.             if ($admissionLimit->getYear() === $this) {
2031.                 $admissionLimit->setYear(null);
2032.             }
2033.         }
2035.         return $this;
2036.     }
2038.     /**
2039.      * @return Collection<int, AgendaDay>
2040.      */
2041.     public function getAgendaDays(): Collection
2042.     {
2043.         return $this->agendaDays;
2044.     }
2046.     public function addAgendaDay(AgendaDay $agendaDay): static
2047.     {
2048.         if (!$this->agendaDays->contains($agendaDay)) {
2049.             $this->agendaDays->add($agendaDay);
2050.             $agendaDay->setYear($this);
2051.         }
2053.         return $this;
2054.     }
2056.     public function removeAgendaDay(AgendaDay $agendaDay): static
2057.     {
2058.         if ($this->agendaDays->removeElement($agendaDay)) {
2059.             // set the owning side to null (unless already changed)
2060.             if ($agendaDay->getYear() === $this) {
2061.                 $agendaDay->setYear(null);
2062.             }
2063.         }
2065.         return $this;
2066.     }
2068.     public function getAgendaTimeConvertion(): ?AgendaTimeConvertion
2069.     {
2070.         return $this->agendaTimeConvertion;
2071.     }
2073.     public function setAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
2074.     {
2075.         // set the owning side of the relation if necessary
2076.         if ($agendaTimeConvertion->getYear() !== $this) {
2077.             $agendaTimeConvertion->setYear($this);
2078.         }
2080.         $this->agendaTimeConvertion = $agendaTimeConvertion;
2082.         return $this;
2083.     }
2085.     /**
2086.      * @return Collection<int, ExamWeek>
2087.      */
2088.     public function getExamWeeks(): Collection
2089.     {
2090.         return $this->examWeeks;
2091.     }
2093.     public function addExamWeek(ExamWeek $examWeek): static
2094.     {
2095.         if (!$this->examWeeks->contains($examWeek)) {
2096.             $this->examWeeks->add($examWeek);
2097.             $examWeek->setYear($this);
2098.         }
2100.         return $this;
2101.     }
2103.     public function removeExamWeek(ExamWeek $examWeek): static
2104.     {
2105.         if ($this->examWeeks->removeElement($examWeek)) {
2106.             // set the owning side to null (unless already changed)
2107.             if ($examWeek->getYear() === $this) {
2108.                 $examWeek->setYear(null);
2109.             }
2110.         }
2112.         return $this;
2113.     }
2115.     /**
2116.      * @return Collection<int, Competence>
2117.      */
2118.     public function getCompetences(): Collection
2119.     {
2120.         return $this->competences;
2121.     }
2123.     public function addCompetence(Competence $competence): static
2124.     {
2125.         if (!$this->competences->contains($competence)) {
2126.             $this->competences->add($competence);
2127.             $competence->setYear($this);
2128.         }
2130.         return $this;
2131.     }
2133.     public function removeCompetence(Competence $competence): static
2134.     {
2135.         if ($this->competences->removeElement($competence)) {
2136.             // set the owning side to null (unless already changed)
2137.             if ($competence->getYear() === $this) {
2138.                 $competence->setYear(null);
2139.             }
2140.         }
2142.         return $this;
2143.     }
2145.     /**
2146.      * @return Collection<int, WeekSubjectGoal>
2147.      */
2148.     public function getWeekSubjectGoals(): Collection
2149.     {
2150.         return $this->weekSubjectGoals;
2151.     }
2153.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
2154.     {
2155.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
2156.             $this->weekSubjectGoals->add($weekSubjectGoal);
2157.             $weekSubjectGoal->setYear($this);
2158.         }
2160.         return $this;
2161.     }
2163.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
2164.     {
2165.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
2166.             // set the owning side to null (unless already changed)
2167.             if ($weekSubjectGoal->getYear() === $this) {
2168.                 $weekSubjectGoal->setYear(null);
2169.             }
2170.         }
2172.         return $this;
2173.     }
2175.     /**
2176.      * @return Collection<int, ProfSchoolPlanner>
2177.      */
2178.     public function getProfSchoolPlanners(): Collection
2179.     {
2180.         return $this->profSchoolPlanners;
2181.     }
2183.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
2184.     {
2185.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
2186.             $this->profSchoolPlanners->add($profSchoolPlanner);
2187.             $profSchoolPlanner->setYear($this);
2188.         }
2190.         return $this;
2191.     }
2193.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
2194.     {
2195.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
2196.             // set the owning side to null (unless already changed)
2197.             if ($profSchoolPlanner->getYear() === $this) {
2198.                 $profSchoolPlanner->setYear(null);
2199.             }
2200.         }
2202.         return $this;
2203.     }
2205.     /**
2206.      * @return Collection<int, ProfTime>
2207.      */
2208.     public function getProfTimes(): Collection
2209.     {
2210.         return $this->profTimes;
2211.     }
2213.     public function addProfTime(ProfTime $profTime): static
2214.     {
2215.         if (!$this->profTimes->contains($profTime)) {
2216.             $this->profTimes->add($profTime);
2217.             $profTime->setYear($this);
2218.         }
2220.         return $this;
2221.     }
2223.     public function removeProfTime(ProfTime $profTime): static
2224.     {
2225.         if ($this->profTimes->removeElement($profTime)) {
2226.             // set the owning side to null (unless already changed)
2227.             if ($profTime->getYear() === $this) {
2228.                 $profTime->setYear(null);
2229.             }
2230.         }
2232.         return $this;
2233.     }
2235.     /**
2236.      * @return Collection<int, SchoolPlannerType>
2237.      */
2238.     public function getSchoolPlannerTypes(): Collection
2239.     {
2240.         return $this->schoolPlannerTypes;
2241.     }
2243.     public function addSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static
2244.     {
2245.         if (!$this->schoolPlannerTypes->contains($schoolPlannerType)) {
2246.             $this->schoolPlannerTypes->add($schoolPlannerType);
2247.             $schoolPlannerType->setYear($this);
2248.         }
2250.         return $this;
2251.     }
2253.     public function removeSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static
2254.     {
2255.         if ($this->schoolPlannerTypes->removeElement($schoolPlannerType)) {
2256.             // set the owning side to null (unless already changed)
2257.             if ($schoolPlannerType->getYear() === $this) {
2258.                 $schoolPlannerType->setYear(null);
2259.             }
2260.         }
2262.         return $this;
2263.     }
2265.     /**
2266.      * @return Collection<int, AgendaElement>
2267.      */
2268.     public function getAgendaElements(): Collection
2269.     {
2270.         return $this->agendaElements;
2271.     }
2273.     public function addAgendaElement(AgendaElement $agendaElement): static
2274.     {
2275.         if (!$this->agendaElements->contains($agendaElement)) {
2276.             $this->agendaElements->add($agendaElement);
2277.             $agendaElement->setYear($this);
2278.         }
2280.         return $this;
2281.     }
2283.     public function removeAgendaElement(AgendaElement $agendaElement): static
2284.     {
2285.         if ($this->agendaElements->removeElement($agendaElement)) {
2286.             // set the owning side to null (unless already changed)
2287.             if ($agendaElement->getYear() === $this) {
2288.                 $agendaElement->setYear(null);
2289.             }
2290.         }
2292.         return $this;
2293.     }
2294. }