src/Entity/SchoolYear.php line 17

Open in your IDE?
  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;
  12. use JMS\Serializer\Annotation\Groups;
  14. #[ORM\HasLifecycleCallbacks]
  15. #[ORM\Entity(repositoryClass: SchoolYearRepository::class)]
  16. #[UniqueEntity(fields: ['name'], message: 'cette année existe deja')]
  17. class SchoolYear
  18. {
  19.     use Timestampable;
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex', 'getDoc', 'getPunish', 'getNews','getNewsSearch', 'homework', 'getEvent', 'getAgenda',  ])]
  24.     private ?int $id = null;
  26.     #[ORM\Column(length: 255)]
  27.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex', 'getDoc', 'getPunish', 'getNews','getNewsSearch', 'homework', 'getEvent', 'getAgenda',  ])]
  28.     private ?string $name = null;
  30.     #[ORM\Column]
  31.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex', 'getDoc', 'getPunish', 'getNews','getNewsSearch', 'homework', 'getEvent', 'getAgenda',  ])]
  32.     private ?bool $active = null;
  34.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: UserYear::class)]
  35.     private Collection $userYears;
  37.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: StudentYear::class)]
  38.     private Collection $studentYears;
  40.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HomeWork::class)]
  41.     private Collection $homeWorks;
  43.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HomeWorkYear::class)]
  44.     private Collection $homeWorkYears;
  46.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Late::class)]
  47.     private Collection $lates;
  49.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Chat::class)]
  50.     private Collection $chats;
  51.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Absence::class)]
  52.     private Collection $absences;
  54.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Note::class)]
  55.     private Collection $notes;
  57.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Exams::class)]
  58.     private Collection $exams;
  60.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DocInfo::class)]
  61.     private Collection $docInfos;
  63.     #[ORM\ManyToOne(inversedBy: 'schoolYears', cascade: ["persist"])]
  64.     private ?User $author = null;
  66.     #[ORM\ManyToOne(inversedBy: 'schoolYearsEdited', cascade: ["persist"])]
  67.     private ?User $editor = null;
  68.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Punish::class)]
  69.     private Collection $punishes;
  71.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Discussion::class)]
  72.     private Collection $discussions;
  74.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DiscussionClass::class)]
  75.     private Collection $discussionClasses;
  77.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Agenda::class)]
  78.     private Collection $agendas;
  80.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ExamAgenda::class)]
  81.     private Collection $examAgendas;
  83.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Quarter::class, orphanRemoval: true)]
  84.     private Collection $quarters;
  86.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalQuarter::class)]
  87.     private Collection $globalQuarters;
  89.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Appreciation::class, orphanRemoval: true)]
  90.     private Collection $appreciations;
  91.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: LocalAccount::class)]
  92.     private Collection $localAccounts;
  94.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineWarning::class)]
  95.     private Collection $disciplineWarnings;
  97.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineBlame::class)]
  98.     private Collection $disciplineBlames;
  100.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineExclusion::class)]
  101.     private Collection $disciplineExclusions;
  103.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ParentNote::class)]
  104.     private Collection $parentNotes;
  106.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: JustifyAbsence::class)]
  107.     private Collection $justifyAbsences;
  109.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Subject::class)]
  110.     private Collection $subjects;
  112.     /**
  113.      * Versions du programme national (SubjectReference) associées à
  114.      * cette année scolaire. Permet de faire évoluer le programme
  115.      * d'une année à l'autre sans perdre l'historique.
  116.      */
  117.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: SubjectReference::class)]
  118.     private Collection $subjectReferences;
  120.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceRetainedConfig::class)]
  121.     private Collection $absenceRetainedConfigs;
  123.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceWarningConfig::class)]
  124.     private Collection $absenceWarningConfigs;
  126.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceExclusionConfig::class)]
  127.     private Collection $absenceExclusionConfigs;
  129.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceBlameConfig::class)]
  130.     private Collection $absenceBlameConfigs;
  132.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineRetained::class)]
  133.     private Collection $disciplineRetaineds;
  135.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DefinitiveExclusion::class)]
  136.     private Collection $definitiveExclusions;
  138.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplineConcile::class)]
  139.     private Collection $disciplineConciles;
  141.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsenceDisciplineConcileConfig::class)]
  142.     private Collection $absenceDisciplineConcileConfigs;
  144.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningBlameConfig::class)]
  145.     private Collection $warningBlameConfigs;
  147.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningDefinitiveExlusionConfig::class)]
  148.     private Collection $warningDefinitiveExlusionConfigs;
  150.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PrimaryParentNote::class)]
  151.     private Collection $primaryParentNotes;
  153.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PrimaryNote::class)]
  154.     private Collection $primaryNotes;
  156.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: VerbalProcessCategory::class)]
  157.     private Collection $verbalProcessCategories;
  159.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalDisciplineConfig::class)]
  160.     private Collection $globalDisciplineConfigs;
  162.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: DisciplinePunish::class)]
  163.     private Collection $disciplinePunishes;
  165.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalDisciplineEnabledConfig::class)]
  166.     private Collection $globalDisciplineEnabledConfigs;
  168.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: BlamePunishConfig::class)]
  169.     private Collection $blamePunishConfigs;
  171.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AbsencePunishConfig::class)]
  172.     private Collection $absencePunishConfigs;
  174.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WarningPunishConfig::class)]
  175.     private Collection $warningPunishConfigs;
  177.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishRetainedConfig::class)]
  178.     private Collection $punishRetainedConfigs;
  180.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishWarningConfig::class)]
  181.     private Collection $punishWarningConfigs;
  183.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishBlameConfig::class)]
  184.     private Collection $punishBlameConfigs;
  186.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: PunishExclusionConfig::class)]
  187.     private Collection $punishExclusionConfigs;
  189.     #[ORM\Column(length: 255)]
  190.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  191.     private ?string $nameEn = null;
  193.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: SchoolYearInfos::class)]
  194.     private Collection $schoolYearInfos;
  196.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Blame::class)]
  197.     private Collection $blames;
  199.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Warning::class)]
  200.     private Collection $warnings;
  202.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Retained::class)]
  203.     private Collection $retaineds;
  205.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: HonnorTableLimitMoy::class)]
  206.     private Collection $honnorTableLimitMoys;
  208.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: News::class)]
  209.     private Collection $news;
  211.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Event::class)]
  212.     private Collection $events;
  214.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AdmissionLimit::class)]
  215.     private Collection $admissionLimits;
  217.     #[ORM\OneToOne(mappedBy: 'year', cascade: ['persist'])]
  218.     private ?AgendaTimeConvertion $agendaTimeConvertion = null;
  220.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ExamWeek::class)]
  221.     private Collection $examWeeks;
  223.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: Competence::class)]
  224.     private Collection $competences;
  226.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: WeekSubjectGoal::class)]
  227.     private Collection $weekSubjectGoals;
  229.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ProfSchoolPlanner::class)]
  230.     private Collection $profSchoolPlanners;
  232.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: ProfTime::class)]
  233.     private Collection $profTimes;
  235.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: SchoolPlannerType::class)]
  236.     private Collection $schoolPlannerTypes;
  238.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AgendaElement::class)]
  239.     private Collection $agendaElements;
  241.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GlobalSchoolBreak::class)]
  242.     private Collection $globalSchoolBreaks;
  244.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: TeacherAbsence::class, orphanRemoval: true)]
  245.     private Collection $teacherAbsences;
  247.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: AttendanceMissed::class)]
  248.     private Collection $attendanceMisseds;
  250.     #[ORM\OneToMany(mappedBy: 'year', targetEntity: GeneralBreak::class, orphanRemoval: true)]
  251.     private Collection $generalBreaks;
  253.     #[ORM\Column(nullable: true)]
  254.     private ?int $level = null;
  256.     public function __construct()
  257.     {
  258.         $this->userYears = new ArrayCollection();
  259.         $this->studentYears = new ArrayCollection();
  260.         $this->homeWorks = new ArrayCollection();
  261.         $this->homeWorkYears = new ArrayCollection();
  262.         $this->lates = new ArrayCollection();
  263.         $this->chats = new ArrayCollection();
  264.         $this->absences = new ArrayCollection();
  265.         $this->notes = new ArrayCollection();
  266.         $this->exams = new ArrayCollection();
  267.         $this->docInfos = new ArrayCollection();
  268.         $this->punishes = new ArrayCollection();
  269.         $this->discussions = new ArrayCollection();
  270.         $this->discussionClasses = new ArrayCollection();
  271.         $this->agendas = new ArrayCollection();
  272.         $this->examAgendas = new ArrayCollection();
  273.         $this->quarters = new ArrayCollection();
  274.         $this->globalQuarters = new ArrayCollection();
  275.         $this->appreciations = new ArrayCollection();
  276.         $this->localAccounts = new ArrayCollection();
  277.         $this->disciplineWarnings = new ArrayCollection();
  278.         $this->disciplineBlames = new ArrayCollection();
  279.         $this->disciplineExclusions = new ArrayCollection();
  280.         $this->parentNotes = new ArrayCollection();
  281.         $this->justifyAbsences = new ArrayCollection();
  282.         $this->subjects = new ArrayCollection();
  283.         $this->subjectReferences = new ArrayCollection();
  284.         $this->absenceRetainedConfigs = new ArrayCollection();
  285.         $this->absenceWarningConfigs = new ArrayCollection();
  286.         $this->absenceExclusionConfigs = new ArrayCollection();
  287.         $this->absenceBlameConfigs = new ArrayCollection();
  288.         $this->disciplineRetaineds = new ArrayCollection();
  289.         $this->definitiveExclusions = new ArrayCollection();
  290.         $this->disciplineConciles = new ArrayCollection();
  291.         $this->absenceDisciplineConcileConfigs = new ArrayCollection();
  292.         $this->warningBlameConfigs = new ArrayCollection();
  293.         $this->warningDefinitiveExlusionConfigs = new ArrayCollection();
  294.         $this->primaryParentNotes = new ArrayCollection();
  295.         $this->primaryNotes = new ArrayCollection();
  296.         $this->verbalProcessCategories = new ArrayCollection();
  297.         $this->globalDisciplineConfigs = new ArrayCollection();
  298.         $this->disciplinePunishes = new ArrayCollection();
  299.         $this->globalDisciplineEnabledConfigs = new ArrayCollection();
  300.         $this->blamePunishConfigs = new ArrayCollection();
  301.         $this->absencePunishConfigs = new ArrayCollection();
  302.         $this->warningPunishConfigs = new ArrayCollection();
  303.         $this->punishRetainedConfigs = new ArrayCollection();
  304.         $this->punishWarningConfigs = new ArrayCollection();
  305.         $this->punishBlameConfigs = new ArrayCollection();
  306.         $this->punishExclusionConfigs = new ArrayCollection();
  307.         $this->schoolYearInfos = new ArrayCollection();
  308.         $this->blames = new ArrayCollection();
  309.         $this->warnings = new ArrayCollection();
  310.         $this->retaineds = new ArrayCollection();
  311.         $this->honnorTableLimitMoys = new ArrayCollection();
  312.         $this->news = new ArrayCollection();
  313.         $this->events = new ArrayCollection();
  314.         $this->admissionLimits = new ArrayCollection();
  315.         $this->examWeeks = new ArrayCollection();
  316.         $this->competences = new ArrayCollection();
  317.         $this->weekSubjectGoals = new ArrayCollection();
  318.         $this->profSchoolPlanners = new ArrayCollection();
  319.         $this->profTimes = new ArrayCollection();
  320.         $this->schoolPlannerTypes = new ArrayCollection();
  321.         $this->agendaElements = new ArrayCollection();
  322.         $this->globalSchoolBreaks = new ArrayCollection();
  323.         $this->teacherAbsences = new ArrayCollection();
  324.         $this->attendanceMisseds = new ArrayCollection();
  325.         $this->generalBreaks = new ArrayCollection();
  326.     }
  328.     public function getId(): ?int
  329.     {
  330.         return $this->id;
  331.     }
  333.     public function getName(): ?string
  334.     {
  335.         return $this->name;
  336.     }
  338.     public function setName(string $name): static
  339.     {
  340.         $this->name = $name;
  342.         return $this;
  343.     }
  345.     public function isActive(): ?bool
  346.     {
  347.         return $this->active;
  348.     }
  350.     public function setActive(bool $active): static
  351.     {
  352.         $this->active = $active;
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, UserYear>
  359.      */
  360.     public function getUserYears(): Collection
  361.     {
  362.         return $this->userYears;
  363.     }
  365.     public function addUserYear(UserYear $userYear): static
  366.     {
  367.         if (!$this->userYears->contains($userYear)) {
  368.             $this->userYears->add($userYear);
  369.             $userYear->setYear($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removeUserYear(UserYear $userYear): static
  376.     {
  377.         if ($this->userYears->removeElement($userYear)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($userYear->getYear() === $this) {
  380.                 $userYear->setYear(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     /**
  388.      * @return Collection<int, StudentYear>
  389.      */
  390.     public function getStudentYears(): Collection
  391.     {
  392.         return $this->studentYears;
  393.     }
  395.     public function addStudentYear(StudentYear $studentYear): static
  396.     {
  397.         if (!$this->studentYears->contains($studentYear)) {
  398.             $this->studentYears->add($studentYear);
  399.             $studentYear->setYear($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeStudentYear(StudentYear $studentYear): static
  406.     {
  407.         if ($this->studentYears->removeElement($studentYear)) {
  408.             // set the owning side to null (unless already changed)
  409.             if ($studentYear->getYear() === $this) {
  410.                 $studentYear->setYear(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection<int, HomeWork>
  419.      */
  420.     public function getHomeWorks(): Collection
  421.     {
  422.         return $this->homeWorks;
  423.     }
  425.     public function addHomeWork(HomeWork $homeWork): static
  426.     {
  427.         if (!$this->homeWorks->contains($homeWork)) {
  428.             $this->homeWorks->add($homeWork);
  429.             $homeWork->setYear($this);
  430.         }
  432.         return $this;
  433.     }
  435.     public function removeHomeWork(HomeWork $homeWork): static
  436.     {
  437.         if ($this->homeWorks->removeElement($homeWork)) {
  438.             // set the owning side to null (unless already changed)
  439.             if ($homeWork->getYear() === $this) {
  440.                 $homeWork->setYear(null);
  441.             }
  442.         }
  444.         return $this;
  445.     }
  447.     /**
  448.      * @return Collection<int, HomeWorkYear>
  449.      */
  450.     public function getHomeWorkYears(): Collection
  451.     {
  452.         return $this->homeWorkYears;
  453.     }
  455.     public function addHomeWorkYear(HomeWorkYear $homeWorkYear): static
  456.     {
  457.         if (!$this->homeWorkYears->contains($homeWorkYear)) {
  458.             $this->homeWorkYears->add($homeWorkYear);
  459.             $homeWorkYear->setYear($this);
  460.         }
  462.         return $this;
  463.     }
  465.     public function removeHomeWorkYear(HomeWorkYear $homeWorkYear): static
  466.     {
  467.         if ($this->homeWorkYears->removeElement($homeWorkYear)) {
  468.             // set the owning side to null (unless already changed)
  469.             if ($homeWorkYear->getYear() === $this) {
  470.                 $homeWorkYear->setYear(null);
  471.             }
  472.         }
  474.         return $this;
  475.     }
  477.     /**
  478.      * @return Collection<int, Late>
  479.      */
  480.     public function getLates(): Collection
  481.     {
  482.         return $this->lates;
  483.     }
  485.     public function addLate(Late $late): static
  486.     {
  487.         if (!$this->lates->contains($late)) {
  488.             $this->lates->add($late);
  489.             $late->setYear($this);
  490.         }
  492.         return $this;
  493.     }
  495.     public function removeLate(Late $late): static
  496.     {
  497.         if ($this->lates->removeElement($late)) {
  498.             // set the owning side to null (unless already changed)
  499.             if ($late->getYear() === $this) {
  500.                 $late->setYear(null);
  501.             }
  502.         }
  504.         return $this;
  505.     }
  507.     /**
  508.      * @return Collection<int, Chat>
  509.      */
  510.     public function getChats(): Collection
  511.     {
  512.         return $this->chats;
  513.     }
  515.     public function addChat(Chat $chat): static
  516.     {
  517.         if (!$this->chats->contains($chat)) {
  518.             $this->chats->add($chat);
  519.             $chat->setYear($this);
  520.         }
  521.     }
  522.     /** 
  523.      * @return Collection<int, Absence>
  524.     */
  525.     public function getAbsences(): Collection
  526.     {
  527.         return $this->absences;
  528.     }
  530.     public function addAbsence(Absence $absence): static
  531.     {
  532.         if (!$this->absences->contains($absence)) {
  533.             $this->absences->add($absence);
  534.             $absence->setYear($this);
  535.         }
  537.         return $this;
  538.     }
  540.     public function removeChat(Chat $chat): static
  541.     {
  542.         if ($this->chats->removeElement($chat)) {
  543.             // set the owning side to null (unless already changed)
  544.             if ($chat->getYear() === $this) {
  545.                 $chat->setYear(null);
  546.             }
  547.         }
  549.         return $this;
  550.     }
  551.     public function removeAbsence(Absence $absence): static
  552.     {
  553.         if ($this->absences->removeElement($absence)) {
  554.             // set the owning side to null (unless already changed)
  555.             if ($absence->getYear() === $this) {
  556.                 $absence->setYear(null);
  557.             }
  558.         }
  560.         return $this;
  561.     }
  563.     /**
  564.      * @return Collection<int, Note>
  565.      */
  566.     public function getNotes(): Collection
  567.     {
  568.         return $this->notes;
  569.     }
  571.     public function addNote(Note $note): static
  572.     {
  573.         if (!$this->notes->contains($note)) {
  574.             $this->notes->add($note);
  575.             $note->setYear($this);
  576.         }
  578.         return $this;
  579.     }
  581.     public function removeNote(Note $note): static
  582.     {
  583.         if ($this->notes->removeElement($note)) {
  584.             // set the owning side to null (unless already changed)
  585.             if ($note->getYear() === $this) {
  586.                 $note->setYear(null);
  587.             }
  588.         }
  590.         return $this;
  591.     }
  593.     /**
  594.      * @return Collection<int, Exams>
  595.      */
  596.     public function getExams(): Collection
  597.     {
  598.         return $this->exams;
  599.     }
  601.     public function addExam(Exams $exam): static
  602.     {
  603.         if (!$this->exams->contains($exam)) {
  604.             $this->exams->add($exam);
  605.             $exam->setYear($this);
  606.         }
  608.         return $this;
  609.     }
  611.     public function removeExam(Exams $exam): static
  612.     {
  613.         if ($this->exams->removeElement($exam)) {
  614.             // set the owning side to null (unless already changed)
  615.             if ($exam->getYear() === $this) {
  616.                 $exam->setYear(null);
  617.             }
  618.         }
  620.         return $this;
  621.     }
  623.     /**
  624.      * @return Collection<int, DocInfo>
  625.      */
  626.     public function getDocInfos(): Collection
  627.     {
  628.         return $this->docInfos;
  629.     }
  631.     public function addDocInfo(DocInfo $docInfo): static
  632.     {
  633.         if (!$this->docInfos->contains($docInfo)) {
  634.             $this->docInfos->add($docInfo);
  635.             $docInfo->setYear($this);
  636.         }
  638.         return $this;
  639.     }
  641.     public function removeDocInfo(DocInfo $docInfo): static
  642.     {
  643.         if ($this->docInfos->removeElement($docInfo)) {
  644.             // set the owning side to null (unless already changed)
  645.             if ($docInfo->getYear() === $this) {
  646.                 $docInfo->setYear(null);
  647.             }
  648.         }
  650.         return $this;
  651.     }
  653.     public function getAuthor(): ?User
  654.     {
  655.         return $this->author;
  656.     }
  658.     public function setAuthor(?User $author): static
  659.     {
  660.         $this->author = $author;
  662.         return $this;
  663.     }
  664.     
  665.     /**
  666.      * @return Collection<int, Punish>
  667.      */
  668.     public function getPunishes(): Collection
  669.     {
  670.         return $this->punishes;
  671.     }
  673.     public function addPunish(Punish $punish): static
  674.     {
  675.         if (!$this->punishes->contains($punish)) {
  676.             $this->punishes->add($punish);
  677.             $punish->setYear($this);
  678.         }
  680.         return $this;
  681.     }
  682.     public function removePunish(Punish $punish): static
  683.     {
  684.         if ($this->punishes->removeElement($punish)) {
  685.             // set the owning side to null (unless already changed)
  686.             if ($punish->getYear() === $this) {
  687.                 $punish->setYear(null);
  688.             }
  689.         }
  691.         return $this;
  692.     }
  694.     public function getEditor(): ?User
  695.     {
  696.         return $this->editor;
  697.     }
  699.     public function setEditor(?User $editor): static
  700.     {
  701.         $this->editor = $editor;
  703.         return $this;
  704.     }
  706.     /**
  707.      * @return Collection<int, Discussion>
  708.      */
  709.     public function getDiscussions(): Collection
  710.     {
  711.         return $this->discussions;
  712.     }
  714.     public function addDiscussion(Discussion $discussion): static
  715.     {
  716.         if (!$this->discussions->contains($discussion)) {
  717.             $this->discussions->add($discussion);
  718.             $discussion->setYear($this);
  719.         }
  721.         return $this;
  722.     }
  724.     public function removeDiscussion(Discussion $discussion): static
  725.     {
  726.         if ($this->discussions->removeElement($discussion)) {
  727.             // set the owning side to null (unless already changed)
  728.             if ($discussion->getYear() === $this) {
  729.                 $discussion->setYear(null);
  730.             }
  731.         }
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return Collection<int, DiscussionClass>
  738.      */
  739.     public function getDiscussionClasses(): Collection
  740.     {
  741.         return $this->discussionClasses;
  742.     }
  744.     public function addDiscussionClass(DiscussionClass $discussionClass): static
  745.     {
  746.         if (!$this->discussionClasses->contains($discussionClass)) {
  747.             $this->discussionClasses->add($discussionClass);
  748.             $discussionClass->setYear($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
  755.     {
  756.         if ($this->discussionClasses->removeElement($discussionClass)) {
  757.             // set the owning side to null (unless already changed)
  758.             if ($discussionClass->getYear() === $this) {
  759.                 $discussionClass->setYear(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     /**
  767.      * @return Collection<int, Agenda>
  768.      */
  769.     public function getAgendas(): Collection
  770.     {
  771.         return $this->agendas;
  772.     }
  774.     public function addAgenda(Agenda $agenda): static
  775.     {
  776.         if (!$this->agendas->contains($agenda)) {
  777.             $this->agendas->add($agenda);
  778.             $agenda->setYear($this);
  779.         }
  781.         return $this;
  782.     }
  784.     public function removeAgenda(Agenda $agenda): static
  785.     {
  786.         if ($this->agendas->removeElement($agenda)) {
  787.             // set the owning side to null (unless already changed)
  788.             if ($agenda->getYear() === $this) {
  789.                 $agenda->setYear(null);
  790.             }
  791.         }
  793.         return $this;
  794.     }
  796.     /**
  797.      * @return Collection<int, ExamAgenda>
  798.      */
  799.     public function getExamAgendas(): Collection
  800.     {
  801.         return $this->examAgendas;
  802.     }
  804.     public function addExamAgenda(ExamAgenda $examAgenda): static
  805.     {
  806.         if (!$this->examAgendas->contains($examAgenda)) {
  807.             $this->examAgendas->add($examAgenda);
  808.             $examAgenda->setYear($this);
  809.         }
  811.         return $this;
  812.     }
  814.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  815.     {
  816.         if ($this->examAgendas->removeElement($examAgenda)) {
  817.             // set the owning side to null (unless already changed)
  818.             if ($examAgenda->getYear() === $this) {
  819.                 $examAgenda->setYear(null);
  820.             }
  821.         }
  823.         return $this;
  824.     }
  826.     /**
  827.      * @return Collection<int, Quarter>
  828.      */
  829.     public function getQuarters(): Collection
  830.     {
  831.         return $this->quarters;
  832.     }
  834.     public function addQuarter(Quarter $quarter): static
  835.     {
  836.         if (!$this->quarters->contains($quarter)) {
  837.             $this->quarters->add($quarter);
  838.             $quarter->setYear($this);
  839.         }
  841.         return $this;
  842.     }
  844.     public function removeQuarter(Quarter $quarter): static
  845.     {
  846.         if ($this->quarters->removeElement($quarter)) {
  847.             // set the owning side to null (unless already changed)
  848.             if ($quarter->getYear() === $this) {
  849.                 $quarter->setYear(null);
  850.             }
  851.         }
  853.         return $this;
  854.     }
  856.     /**
  857.      * @return Collection<int, GlobalQuarter>
  858.      */
  859.     public function getGlobalQuarters(): Collection
  860.     {
  861.         return $this->globalQuarters;
  862.     }
  864.     public function addGlobalQuarter(GlobalQuarter $globalQuarter): static
  865.     {
  866.         if (!$this->globalQuarters->contains($globalQuarter)) {
  867.             $this->globalQuarters->add($globalQuarter);
  868.             $globalQuarter->setYear($this);
  869.         }
  870.         return $this;
  871.     }
  873.     public function removeGlobalQuarter(GlobalQuarter $globalQuarter): static
  874.     {
  875.         if ($this->globalQuarters->removeElement($globalQuarter)) {
  876.             // set the owning side to null (unless already changed)
  877.             if ($globalQuarter->getYear() === $this) {
  878.                 $globalQuarter->setYear(null);
  879.             }
  880.         }
  882.         return $this;
  883.     }
  885.     /**
  886.      * @return Collection<int, LocalAccount>
  887.      */
  888.     public function getLocalAccounts(): Collection
  889.     {
  890.         return $this->localAccounts;
  891.     }
  893.     public function addLocalAccount(LocalAccount $localAccount): static
  894.     {
  895.         if (!$this->localAccounts->contains($localAccount)) {
  896.             $this->localAccounts->add($localAccount);
  897.             $localAccount->setYear($this);
  898.         }
  900.         return $this;
  901.     }
  903.     public function removeLocalAccount(LocalAccount $localAccount): static
  904.     {
  905.         if ($this->localAccounts->removeElement($localAccount)) {
  906.             // set the owning side to null (unless already changed)
  907.             if ($localAccount->getYear() === $this) {
  908.                 $localAccount->setYear(null);
  909.             }
  910.         }
  912.         return $this;
  913.     }
  915.     /**
  916.      * @return Collection<int, Appreciation>
  917.      */
  918.     public function getAppreciations(): Collection
  919.     {
  920.         return $this->appreciations;
  921.     }
  923.     public function addAppreciation(Appreciation $appreciation): static
  924.     {
  925.         if (!$this->appreciations->contains($appreciation)) {
  926.             $this->appreciations->add($appreciation);
  927.             $appreciation->setYear($this);
  928.         }
  930.         return $this;
  931.     }
  933.     public function removeAppreciation(Appreciation $appreciation): static
  934.     {
  935.         if ($this->appreciations->removeElement($appreciation)) {
  936.             // set the owning side to null (unless already changed)
  937.             if ($appreciation->getYear() === $this) {
  938.                 $appreciation->setYear(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  945.     /**
  946.      * @return Collection<int, DisciplineWarning>
  947.      */
  948.     public function getDisciplineWarnings(): Collection
  949.     {
  950.         return $this->disciplineWarnings;
  951.     }
  953.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  954.     {
  955.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  956.             $this->disciplineWarnings->add($disciplineWarning);
  957.             $disciplineWarning->setYear($this);
  958.         }
  960.         return $this;
  961.     }
  963.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  964.     {
  965.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  966.             // set the owning side to null (unless already changed)
  967.             if ($disciplineWarning->getYear() === $this) {
  968.                 $disciplineWarning->setYear(null);
  969.             }
  970.         }
  972.         return $this;
  973.     }
  975.     /**
  976.      * @return Collection<int, DisciplineBlame>
  977.      */
  978.     public function getDisciplineBlames(): Collection
  979.     {
  980.         return $this->disciplineBlames;
  981.     }
  983.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  984.     {
  985.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  986.             $this->disciplineBlames->add($disciplineBlame);
  987.             $disciplineBlame->setYear($this);
  988.         }
  990.         return $this;
  991.     }
  993.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  994.     {
  995.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  996.             // set the owning side to null (unless already changed)
  997.             if ($disciplineBlame->getYear() === $this) {
  998.                 $disciplineBlame->setYear(null);
  999.             }
  1000.         }
  1002.         return $this;
  1003.     }
  1005.     /**
  1006.      * @return Collection<int, DisciplineExclusion>
  1007.      */
  1008.     public function getDisciplineExclusions(): Collection
  1009.     {
  1010.         return $this->disciplineExclusions;
  1011.     }
  1013.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  1014.     {
  1015.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  1016.             $this->disciplineExclusions->add($disciplineExclusion);
  1017.             $disciplineExclusion->setYear($this);
  1018.         }
  1020.         return $this;
  1021.     }
  1023.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  1024.     {
  1025.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  1026.             // set the owning side to null (unless already changed)
  1027.             if ($disciplineExclusion->getYear() === $this) {
  1028.                 $disciplineExclusion->setYear(null);
  1029.             }
  1030.         }
  1032.         return $this;
  1033.     }
  1035.     /**
  1036.      * @return Collection<int, ParentNote>
  1037.      */
  1038.     public function getParentNotes(): Collection
  1039.     {
  1040.         return $this->parentNotes;
  1041.     }
  1043.     public function addParentNote(ParentNote $parentNote): static
  1044.     {
  1045.         if (!$this->parentNotes->contains($parentNote)) {
  1046.             $this->parentNotes->add($parentNote);
  1047.             $parentNote->setYear($this);
  1048.         }
  1050.         return $this;
  1051.     }
  1053.     public function removeParentNote(ParentNote $parentNote): static
  1054.     {
  1055.         if ($this->parentNotes->removeElement($parentNote)) {
  1056.             // set the owning side to null (unless already changed)
  1057.             if ($parentNote->getYear() === $this) {
  1058.                 $parentNote->setYear(null);
  1059.             }
  1060.         }
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * @return Collection<int, JustifyAbsence>
  1067.      */
  1068.     public function getJustifyAbsences(): Collection
  1069.     {
  1070.         return $this->justifyAbsences;
  1071.     }
  1073.     public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static
  1074.     {
  1075.         if (!$this->justifyAbsences->contains($justifyAbsence)) {
  1076.             $this->justifyAbsences->add($justifyAbsence);
  1077.             $justifyAbsence->setYear($this);
  1078.         }
  1080.         return $this;
  1081.     }
  1083.     public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static
  1084.     {
  1085.         if ($this->justifyAbsences->removeElement($justifyAbsence)) {
  1086.             // set the owning side to null (unless already changed)
  1087.             if ($justifyAbsence->getYear() === $this) {
  1088.                 $justifyAbsence->setYear(null);
  1089.             }
  1090.         }
  1092.         return $this;
  1093.     }
  1095.     /**
  1096.      * @return Collection<int, Subject>
  1097.      */
  1098.     public function getSubjects(): Collection
  1099.     {
  1100.         return $this->subjects;
  1101.     }
  1103.     public function addSubject(Subject $subject): static
  1104.     {
  1105.         if (!$this->subjects->contains($subject)) {
  1106.             $this->subjects->add($subject);
  1107.             $subject->setYear($this);
  1108.         }
  1110.         return $this;
  1111.     }
  1113.     public function removeSubject(Subject $subject): static
  1114.     {
  1115.         if ($this->subjects->removeElement($subject)) {
  1116.             // set the owning side to null (unless already changed)
  1117.             if ($subject->getYear() === $this) {
  1118.                 $subject->setYear(null);
  1119.             }
  1120.         }
  1122.         return $this;
  1123.     }
  1125.     /**
  1126.      * @return Collection<int, SubjectReference>
  1127.      */
  1128.     public function getSubjectReferences(): Collection
  1129.     {
  1130.         return $this->subjectReferences;
  1131.     }
  1133.     public function addSubjectReference(SubjectReference $subjectReference): static
  1134.     {
  1135.         if (!$this->subjectReferences->contains($subjectReference)) {
  1136.             $this->subjectReferences->add($subjectReference);
  1137.             $subjectReference->setYear($this);
  1138.         }
  1140.         return $this;
  1141.     }
  1143.     public function removeSubjectReference(SubjectReference $subjectReference): static
  1144.     {
  1145.         if ($this->subjectReferences->removeElement($subjectReference)) {
  1146.             if ($subjectReference->getYear() === $this) {
  1147.                 $subjectReference->setYear(null);
  1148.             }
  1149.         }
  1151.         return $this;
  1152.     }
  1154.     /**
  1155.      * @return Collection<int, AbsenceRetainedConfig>
  1156.      */
  1157.     public function getAbsenceRetainedConfigs(): Collection
  1158.     {
  1159.         return $this->absenceRetainedConfigs;
  1160.     }
  1162.     public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  1163.     {
  1164.         if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) {
  1165.             $this->absenceRetainedConfigs->add($absenceRetainedConfig);
  1166.             $absenceRetainedConfig->setYear($this);
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static
  1173.     {
  1174.         if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) {
  1175.             // set the owning side to null (unless already changed)
  1176.             if ($absenceRetainedConfig->getYear() === $this) {
  1177.                 $absenceRetainedConfig->setYear(null);
  1178.             }
  1179.         }
  1181.         return $this;
  1182.     }
  1184.     /**
  1185.      * @return Collection<int, AbsenceWarningConfig>
  1186.      */
  1187.     public function getAbsenceWarningConfigs(): Collection
  1188.     {
  1189.         return $this->absenceWarningConfigs;
  1190.     }
  1192.     public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  1193.     {
  1194.         if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) {
  1195.             $this->absenceWarningConfigs->add($absenceWarningConfig);
  1196.             $absenceWarningConfig->setYear($this);
  1197.         }
  1199.         return $this;
  1200.     }
  1202.     public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static
  1203.     {
  1204.         if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) {
  1205.             // set the owning side to null (unless already changed)
  1206.             if ($absenceWarningConfig->getYear() === $this) {
  1207.                 $absenceWarningConfig->setYear(null);
  1208.             }
  1209.         }
  1211.         return $this;
  1212.     }
  1214.     /**
  1215.      * @return Collection<int, AbsenceExclusionConfig>
  1216.      */
  1217.     public function getAbsenceExclusionConfigs(): Collection
  1218.     {
  1219.         return $this->absenceExclusionConfigs;
  1220.     }
  1222.     public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  1223.     {
  1224.         if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) {
  1225.             $this->absenceExclusionConfigs->add($absenceExclusionConfig);
  1226.             $absenceExclusionConfig->setYear($this);
  1227.         }
  1229.         return $this;
  1230.     }
  1232.     public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static
  1233.     {
  1234.         if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) {
  1235.             // set the owning side to null (unless already changed)
  1236.             if ($absenceExclusionConfig->getYear() === $this) {
  1237.                 $absenceExclusionConfig->setYear(null);
  1238.             }
  1239.         }
  1241.         return $this;
  1242.     }
  1244.     /**
  1245.      * @return Collection<int, AbsenceBlameConfig>
  1246.      */
  1247.     public function getAbsenceBlameConfigs(): Collection
  1248.     {
  1249.         return $this->absenceBlameConfigs;
  1250.     }
  1252.     public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  1253.     {
  1254.         if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) {
  1255.             $this->absenceBlameConfigs->add($absenceBlameConfig);
  1256.             $absenceBlameConfig->setYear($this);
  1257.         }
  1259.         return $this;
  1260.     }
  1262.     public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static
  1263.     {
  1264.         if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) {
  1265.             // set the owning side to null (unless already changed)
  1266.             if ($absenceBlameConfig->getYear() === $this) {
  1267.                 $absenceBlameConfig->setYear(null);
  1268.             }
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     /**
  1275.      * @return Collection<int, DisciplineRetained>
  1276.      */
  1277.     public function getDisciplineRetaineds(): Collection
  1278.     {
  1279.         return $this->disciplineRetaineds;
  1280.     }
  1282.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  1283.     {
  1284.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  1285.             $this->disciplineRetaineds->add($disciplineRetained);
  1286.             $disciplineRetained->setYear($this);
  1287.         }
  1289.         return $this;
  1290.     }
  1292.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  1293.     {
  1294.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  1295.             // set the owning side to null (unless already changed)
  1296.             if ($disciplineRetained->getYear() === $this) {
  1297.                 $disciplineRetained->setYear(null);
  1298.             }
  1299.         }
  1301.         return $this;
  1302.     }
  1304.     /**
  1305.      * @return Collection<int, DefinitiveExclusion>
  1306.      */
  1307.     public function getDefinitiveExclusions(): Collection
  1308.     {
  1309.         return $this->definitiveExclusions;
  1310.     }
  1312.     public function addDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
  1313.     {
  1314.         if (!$this->definitiveExclusions->contains($definitiveExclusion)) {
  1315.             $this->definitiveExclusions->add($definitiveExclusion);
  1316.             $definitiveExclusion->setYear($this);
  1317.         }
  1319.         return $this;
  1320.     }
  1322.     public function removeDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
  1323.     {
  1324.         if ($this->definitiveExclusions->removeElement($definitiveExclusion)) {
  1325.             // set the owning side to null (unless already changed)
  1326.             if ($definitiveExclusion->getYear() === $this) {
  1327.                 $definitiveExclusion->setYear(null);
  1328.             }
  1329.         }
  1331.         return $this;
  1332.     }
  1334.     /**
  1335.      * @return Collection<int, DisciplineConcile>
  1336.      */
  1337.     public function getDisciplineConciles(): Collection
  1338.     {
  1339.         return $this->disciplineConciles;
  1340.     }
  1342.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1343.     {
  1344.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  1345.             $this->disciplineConciles->add($disciplineConcile);
  1346.             $disciplineConcile->setYear($this);
  1347.         }
  1349.         return $this;
  1350.     }
  1352.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1353.     {
  1354.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  1355.             // set the owning side to null (unless already changed)
  1356.             if ($disciplineConcile->getYear() === $this) {
  1357.                 $disciplineConcile->setYear(null);
  1358.             }
  1359.         }
  1361.         return $this;
  1362.     }
  1364.     /**
  1365.      * @return Collection<int, AbsenceDisciplineConcileConfig>
  1366.      */
  1367.     public function getAbsenceDisciplineConcileConfigs(): Collection
  1368.     {
  1369.         return $this->absenceDisciplineConcileConfigs;
  1370.     }
  1372.     public function addAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  1373.     {
  1374.         if (!$this->absenceDisciplineConcileConfigs->contains($absenceDisciplineConcileConfig)) {
  1375.             $this->absenceDisciplineConcileConfigs->add($absenceDisciplineConcileConfig);
  1376.             $absenceDisciplineConcileConfig->setYear($this);
  1377.         }
  1379.         return $this;
  1380.     }
  1382.     public function removeAbsenceDisciplineConcileConfig(AbsenceDisciplineConcileConfig $absenceDisciplineConcileConfig): static
  1383.     {
  1384.         if ($this->absenceDisciplineConcileConfigs->removeElement($absenceDisciplineConcileConfig)) {
  1385.             // set the owning side to null (unless already changed)
  1386.             if ($absenceDisciplineConcileConfig->getYear() === $this) {
  1387.                 $absenceDisciplineConcileConfig->setYear(null);
  1388.             }
  1389.         }
  1391.         return $this;
  1392.     }
  1394.     /**
  1395.      * @return Collection<int, WarningBlameConfig>
  1396.      */
  1397.     public function getWarningBlameConfigs(): Collection
  1398.     {
  1399.         return $this->warningBlameConfigs;
  1400.     }
  1402.     public function addWarningBlameConfig(WarningBlameConfig $warningBlameConfig): static
  1403.     {
  1404.         if (!$this->warningBlameConfigs->contains($warningBlameConfig)) {
  1405.             $this->warningBlameConfigs->add($warningBlameConfig);
  1406.             $warningBlameConfig->setYear($this);
  1407.         }
  1409.         return $this;
  1410.     }
  1412.     public function removeWarningBlameConfig(WarningBlameConfig $warningBlameConfig): static
  1413.     {
  1414.         if ($this->warningBlameConfigs->removeElement($warningBlameConfig)) {
  1415.             // set the owning side to null (unless already changed)
  1416.             if ($warningBlameConfig->getYear() === $this) {
  1417.                 $warningBlameConfig->setYear(null);
  1418.             }
  1419.         }
  1421.         return $this;
  1422.     }
  1424.     /**
  1425.      * @return Collection<int, WarningDefinitiveExlusionConfig>
  1426.      */
  1427.     public function getWarningDefinitiveExlusionConfigs(): Collection
  1428.     {
  1429.         return $this->warningDefinitiveExlusionConfigs;
  1430.     }
  1432.     public function addWarningDefinitiveExlusionConfig(WarningDefinitiveExlusionConfig $warningDefinitiveExlusionConfig): static
  1433.     {
  1434.         if (!$this->warningDefinitiveExlusionConfigs->contains($warningDefinitiveExlusionConfig)) {
  1435.             $this->warningDefinitiveExlusionConfigs->add($warningDefinitiveExlusionConfig);
  1436.             $warningDefinitiveExlusionConfig->setYear($this);
  1437.         }
  1439.         return $this;
  1440.     }
  1442.     public function removeWarningDefinitiveExlusionConfig(WarningDefinitiveExlusionConfig $warningDefinitiveExlusionConfig): static
  1443.     {
  1444.         if ($this->warningDefinitiveExlusionConfigs->removeElement($warningDefinitiveExlusionConfig)) {
  1445.             // set the owning side to null (unless already changed)
  1446.             if ($warningDefinitiveExlusionConfig->getYear() === $this) {
  1447.                 $warningDefinitiveExlusionConfig->setYear(null);
  1448.             }
  1449.         }
  1451.         return $this;
  1452.     }
  1454.     /**
  1455.      * @return Collection<int, PrimaryParentNote>
  1456.      */
  1457.     public function getPrimaryParentNotes(): Collection
  1458.     {
  1459.         return $this->primaryParentNotes;
  1460.     }
  1462.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  1463.     {
  1464.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
  1465.             $this->primaryParentNotes->add($primaryParentNote);
  1466.             $primaryParentNote->setYear($this);
  1467.         }
  1469.         return $this;
  1470.     }
  1472.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  1473.     {
  1474.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
  1475.             // set the owning side to null (unless already changed)
  1476.             if ($primaryParentNote->getYear() === $this) {
  1477.                 $primaryParentNote->setYear(null);
  1478.             }
  1479.         }
  1481.         return $this;
  1482.     }
  1484.     /**
  1485.      * @return Collection<int, PrimaryNote>
  1486.      */
  1487.     public function getPrimaryNotes(): Collection
  1488.     {
  1489.         return $this->primaryNotes;
  1490.     }
  1492.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  1493.     {
  1494.         if (!$this->primaryNotes->contains($primaryNote)) {
  1495.             $this->primaryNotes->add($primaryNote);
  1496.             $primaryNote->setYear($this);
  1497.         }
  1499.         return $this;
  1500.     }
  1502.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  1503.     {
  1504.         if ($this->primaryNotes->removeElement($primaryNote)) {
  1505.             // set the owning side to null (unless already changed)
  1506.             if ($primaryNote->getYear() === $this) {
  1507.                 $primaryNote->setYear(null);
  1508.             }
  1509.         }
  1511.         return $this;
  1512.     }
  1514.     /**
  1515.      * @return Collection<int, VerbalProcessCategory>
  1516.      */
  1517.     public function getVerbalProcessCategories(): Collection
  1518.     {
  1519.         return $this->verbalProcessCategories;
  1520.     }
  1522.     public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  1523.     {
  1524.         if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) {
  1525.             $this->verbalProcessCategories->add($verbalProcessCategory);
  1526.             $verbalProcessCategory->setYear($this);
  1527.         }
  1529.         return $this;
  1530.     }
  1532.     public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static
  1533.     {
  1534.         if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) {
  1535.             // set the owning side to null (unless already changed)
  1536.             if ($verbalProcessCategory->getYear() === $this) {
  1537.                 $verbalProcessCategory->setYear(null);
  1538.             }
  1539.         }
  1541.         return $this;
  1542.     }
  1544.     /**
  1545.      * @return Collection<int, GlobalDisciplineConfig>
  1546.      */
  1547.     public function getGlobalDisciplineConfigs(): Collection
  1548.     {
  1549.         return $this->globalDisciplineConfigs;
  1550.     }
  1552.     public function addGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static
  1553.     {
  1554.         if (!$this->globalDisciplineConfigs->contains($globalDisciplineConfig)) {
  1555.             $this->globalDisciplineConfigs->add($globalDisciplineConfig);
  1556.             $globalDisciplineConfig->setYear($this);
  1557.         }
  1559.         return $this;
  1560.     }
  1562.     public function removeGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static
  1563.     {
  1564.         if ($this->globalDisciplineConfigs->removeElement($globalDisciplineConfig)) {
  1565.             // set the owning side to null (unless already changed)
  1566.             if ($globalDisciplineConfig->getYear() === $this) {
  1567.                 $globalDisciplineConfig->setYear(null);
  1568.             }
  1569.         }
  1571.         return $this;
  1572.     }
  1574.     /**
  1575.      * @return Collection<int, DisciplinePunish>
  1576.      */
  1577.     public function getDisciplinePunishes(): Collection
  1578.     {
  1579.         return $this->disciplinePunishes;
  1580.     }
  1582.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  1583.     {
  1584.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  1585.             $this->disciplinePunishes->add($disciplinePunish);
  1586.             $disciplinePunish->setYear($this);
  1587.         }
  1589.         return $this;
  1590.     }
  1592.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  1593.     {
  1594.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  1595.             // set the owning side to null (unless already changed)
  1596.             if ($disciplinePunish->getYear() === $this) {
  1597.                 $disciplinePunish->setYear(null);
  1598.             }
  1599.         }
  1601.         return $this;
  1602.     }
  1604.     /**
  1605.      * @return Collection<int, GlobalDisciplineEnabledConfig>
  1606.      */
  1607.     public function getGlobalDisciplineEnabledConfigs(): Collection
  1608.     {
  1609.         return $this->globalDisciplineEnabledConfigs;
  1610.     }
  1612.     public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  1613.     {
  1614.         if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) {
  1615.             $this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig);
  1616.             $globalDisciplineEnabledConfig->setYear($this);
  1617.         }
  1619.         return $this;
  1620.     }
  1622.     public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static
  1623.     {
  1624.         if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) {
  1625.             // set the owning side to null (unless already changed)
  1626.             if ($globalDisciplineEnabledConfig->getYear() === $this) {
  1627.                 $globalDisciplineEnabledConfig->setYear(null);
  1628.             }
  1629.         }
  1631.         return $this;
  1632.     }
  1634.     /**
  1635.      * @return Collection<int, BlamePunishConfig>
  1636.      */
  1637.     public function getBlamePunishConfigs(): Collection
  1638.     {
  1639.         return $this->blamePunishConfigs;
  1640.     }
  1642.     public function addBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static
  1643.     {
  1644.         if (!$this->blamePunishConfigs->contains($blamePunishConfig)) {
  1645.             $this->blamePunishConfigs->add($blamePunishConfig);
  1646.             $blamePunishConfig->setYear($this);
  1647.         }
  1649.         return $this;
  1650.     }
  1652.     public function removeBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static
  1653.     {
  1654.         if ($this->blamePunishConfigs->removeElement($blamePunishConfig)) {
  1655.             // set the owning side to null (unless already changed)
  1656.             if ($blamePunishConfig->getYear() === $this) {
  1657.                 $blamePunishConfig->setYear(null);
  1658.             }
  1659.         }
  1661.         return $this;
  1662.     }
  1664.     /**
  1665.      * @return Collection<int, AbsencePunishConfig>
  1666.      */
  1667.     public function getAbsencePunishConfigs(): Collection
  1668.     {
  1669.         return $this->absencePunishConfigs;
  1670.     }
  1672.     public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  1673.     {
  1674.         if (!$this->absencePunishConfigs->contains($absencePunishConfig)) {
  1675.             $this->absencePunishConfigs->add($absencePunishConfig);
  1676.             $absencePunishConfig->setYear($this);
  1677.         }
  1679.         return $this;
  1680.     }
  1682.     public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static
  1683.     {
  1684.         if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) {
  1685.             // set the owning side to null (unless already changed)
  1686.             if ($absencePunishConfig->getYear() === $this) {
  1687.                 $absencePunishConfig->setYear(null);
  1688.             }
  1689.         }
  1691.         return $this;
  1692.     }
  1694.     /**
  1695.      * @return Collection<int, WarningPunishConfig>
  1696.      */
  1697.     public function getWarningPunishConfigs(): Collection
  1698.     {
  1699.         return $this->warningPunishConfigs;
  1700.     }
  1702.     public function addWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static
  1703.     {
  1704.         if (!$this->warningPunishConfigs->contains($warningPunishConfig)) {
  1705.             $this->warningPunishConfigs->add($warningPunishConfig);
  1706.             $warningPunishConfig->setYear($this);
  1707.         }
  1709.         return $this;
  1710.     }
  1712.     public function removeWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static
  1713.     {
  1714.         if ($this->warningPunishConfigs->removeElement($warningPunishConfig)) {
  1715.             // set the owning side to null (unless already changed)
  1716.             if ($warningPunishConfig->getYear() === $this) {
  1717.                 $warningPunishConfig->setYear(null);
  1718.             }
  1719.         }
  1721.         return $this;
  1722.     }
  1724.     /**
  1725.      * @return Collection<int, PunishRetainedConfig>
  1726.      */
  1727.     public function getPunishRetainedConfigs(): Collection
  1728.     {
  1729.         return $this->punishRetainedConfigs;
  1730.     }
  1732.     public function addPunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static
  1733.     {
  1734.         if (!$this->punishRetainedConfigs->contains($punishRetainedConfig)) {
  1735.             $this->punishRetainedConfigs->add($punishRetainedConfig);
  1736.             $punishRetainedConfig->setYear($this);
  1737.         }
  1739.         return $this;
  1740.     }
  1742.     public function removePunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static
  1743.     {
  1744.         if ($this->punishRetainedConfigs->removeElement($punishRetainedConfig)) {
  1745.             // set the owning side to null (unless already changed)
  1746.             if ($punishRetainedConfig->getYear() === $this) {
  1747.                 $punishRetainedConfig->setYear(null);
  1748.             }
  1749.         }
  1751.         return $this;
  1752.     }
  1754.     /**
  1755.      * @return Collection<int, PunishWarningConfig>
  1756.      */
  1757.     public function getPunishWarningConfigs(): Collection
  1758.     {
  1759.         return $this->punishWarningConfigs;
  1760.     }
  1762.     public function addPunishWarningConfig(PunishWarningConfig $punishWarningConfig): static
  1763.     {
  1764.         if (!$this->punishWarningConfigs->contains($punishWarningConfig)) {
  1765.             $this->punishWarningConfigs->add($punishWarningConfig);
  1766.             $punishWarningConfig->setYear($this);
  1767.         }
  1769.         return $this;
  1770.     }
  1772.     public function removePunishWarningConfig(PunishWarningConfig $punishWarningConfig): static
  1773.     {
  1774.         if ($this->punishWarningConfigs->removeElement($punishWarningConfig)) {
  1775.             // set the owning side to null (unless already changed)
  1776.             if ($punishWarningConfig->getYear() === $this) {
  1777.                 $punishWarningConfig->setYear(null);
  1778.             }
  1779.         }
  1781.         return $this;
  1782.     }
  1784.     /**
  1785.      * @return Collection<int, PunishBlameConfig>
  1786.      */
  1787.     public function getPunishBlameConfigs(): Collection
  1788.     {
  1789.         return $this->punishBlameConfigs;
  1790.     }
  1792.     public function addPunishBlameConfig(PunishBlameConfig $punishBlameConfig): static
  1793.     {
  1794.         if (!$this->punishBlameConfigs->contains($punishBlameConfig)) {
  1795.             $this->punishBlameConfigs->add($punishBlameConfig);
  1796.             $punishBlameConfig->setYear($this);
  1797.         }
  1799.         return $this;
  1800.     }
  1802.     public function removePunishBlameConfig(PunishBlameConfig $punishBlameConfig): static
  1803.     {
  1804.         if ($this->punishBlameConfigs->removeElement($punishBlameConfig)) {
  1805.             // set the owning side to null (unless already changed)
  1806.             if ($punishBlameConfig->getYear() === $this) {
  1807.                 $punishBlameConfig->setYear(null);
  1808.             }
  1809.         }
  1811.         return $this;
  1812.     }
  1814.     /**
  1815.      * @return Collection<int, PunishExclusionConfig>
  1816.      */
  1817.     public function getPunishExclusionConfigs(): Collection
  1818.     {
  1819.         return $this->punishExclusionConfigs;
  1820.     }
  1822.     public function addPunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static
  1823.     {
  1824.         if (!$this->punishExclusionConfigs->contains($punishExclusionConfig)) {
  1825.             $this->punishExclusionConfigs->add($punishExclusionConfig);
  1826.             $punishExclusionConfig->setYear($this);
  1827.         }
  1829.         return $this;
  1830.     }
  1832.     public function removePunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static
  1833.     {
  1834.         if ($this->punishExclusionConfigs->removeElement($punishExclusionConfig)) {
  1835.             // set the owning side to null (unless already changed)
  1836.             if ($punishExclusionConfig->getYear() === $this) {
  1837.                 $punishExclusionConfig->setYear(null);
  1838.             }
  1839.         }
  1841.         return $this;
  1842.     }
  1844.     public function getNameEn(): ?string
  1845.     {
  1846.         return $this->nameEn;
  1847.     }
  1849.     public function setNameEn(string $nameEn): static
  1850.     {
  1851.         $this->nameEn = $nameEn;
  1853.         return $this;
  1854.     }
  1856.     /**
  1857.      * @return Collection<int, SchoolYearInfos>
  1858.      */
  1859.     public function getSchoolYearInfos(): Collection
  1860.     {
  1861.         return $this->schoolYearInfos;
  1862.     }
  1864.     public function addSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static
  1865.     {
  1866.         if (!$this->schoolYearInfos->contains($schoolYearInfo)) {
  1867.             $this->schoolYearInfos->add($schoolYearInfo);
  1868.             $schoolYearInfo->setYear($this);
  1869.         }
  1871.         return $this;
  1872.     }
  1874.     public function removeSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static
  1875.     {
  1876.         if ($this->schoolYearInfos->removeElement($schoolYearInfo)) {
  1877.             // set the owning side to null (unless already changed)
  1878.             if ($schoolYearInfo->getYear() === $this) {
  1879.                 $schoolYearInfo->setYear(null);
  1880.             }
  1881.         }
  1883.         return $this;
  1884.     }
  1886.     /**
  1887.      * @return Collection<int, Blame>
  1888.      */
  1889.     public function getBlames(): Collection
  1890.     {
  1891.         return $this->blames;
  1892.     }
  1894.     public function addBlame(Blame $blame): static
  1895.     {
  1896.         if (!$this->blames->contains($blame)) {
  1897.             $this->blames->add($blame);
  1898.             $blame->setYear($this);
  1899.         }
  1901.         return $this;
  1902.     }
  1904.     public function removeBlame(Blame $blame): static
  1905.     {
  1906.         if ($this->blames->removeElement($blame)) {
  1907.             // set the owning side to null (unless already changed)
  1908.             if ($blame->getYear() === $this) {
  1909.                 $blame->setYear(null);
  1910.             }
  1911.         }
  1913.         return $this;
  1914.     }
  1916.     /**
  1917.      * @return Collection<int, Warning>
  1918.      */
  1919.     public function getWarnings(): Collection
  1920.     {
  1921.         return $this->warnings;
  1922.     }
  1924.     public function addWarning(Warning $warning): static
  1925.     {
  1926.         if (!$this->warnings->contains($warning)) {
  1927.             $this->warnings->add($warning);
  1928.             $warning->setYear($this);
  1929.         }
  1931.         return $this;
  1932.     }
  1934.     public function removeWarning(Warning $warning): static
  1935.     {
  1936.         if ($this->warnings->removeElement($warning)) {
  1937.             // set the owning side to null (unless already changed)
  1938.             if ($warning->getYear() === $this) {
  1939.                 $warning->setYear(null);
  1940.             }
  1941.         }
  1943.         return $this;
  1944.     }
  1946.     /**
  1947.      * @return Collection<int, Retained>
  1948.      */
  1949.     public function getRetaineds(): Collection
  1950.     {
  1951.         return $this->retaineds;
  1952.     }
  1954.     public function addRetained(Retained $retained): static
  1955.     {
  1956.         if (!$this->retaineds->contains($retained)) {
  1957.             $this->retaineds->add($retained);
  1958.             $retained->setYear($this);
  1959.         }
  1961.         return $this;
  1962.     }
  1964.     public function removeRetained(Retained $retained): static
  1965.     {
  1966.         if ($this->retaineds->removeElement($retained)) {
  1967.             // set the owning side to null (unless already changed)
  1968.             if ($retained->getYear() === $this) {
  1969.                 $retained->setYear(null);
  1970.             }
  1971.         }
  1973.         return $this;
  1974.     }
  1976.     /**
  1977.      * @return Collection<int, HonnorTableLimitMoy>
  1978.      */
  1979.     public function getHonnorTableLimitMoys(): Collection
  1980.     {
  1981.         return $this->honnorTableLimitMoys;
  1982.     }
  1984.     public function addHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static
  1985.     {
  1986.         if (!$this->honnorTableLimitMoys->contains($honnorTableLimitMoy)) {
  1987.             $this->honnorTableLimitMoys->add($honnorTableLimitMoy);
  1988.             $honnorTableLimitMoy->setYear($this);
  1989.         }
  1991.         return $this;
  1992.     }
  1994.     public function removeHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static
  1995.     {
  1996.         if ($this->honnorTableLimitMoys->removeElement($honnorTableLimitMoy)) {
  1997.             // set the owning side to null (unless already changed)
  1998.             if ($honnorTableLimitMoy->getYear() === $this) {
  1999.                 $honnorTableLimitMoy->setYear(null);
  2000.             }
  2001.         }
  2003.         return $this;
  2004.     }
  2006.     /**
  2007.      * @return Collection<int, News>
  2008.      */
  2009.     public function getNews(): Collection
  2010.     {
  2011.         return $this->news;
  2012.     }
  2014.     public function addNews(News $news): static
  2015.     {
  2016.         if (!$this->news->contains($news)) {
  2017.             $this->news->add($news);
  2018.             $news->setYear($this);
  2019.         }
  2021.         return $this;
  2022.     }
  2024.     public function removeNews(News $news): static
  2025.     {
  2026.         if ($this->news->removeElement($news)) {
  2027.             // set the owning side to null (unless already changed)
  2028.             if ($news->getYear() === $this) {
  2029.                 $news->setYear(null);
  2030.             }
  2031.         }
  2033.         return $this;
  2034.     }
  2036.     /**
  2037.      * @return Collection<int, Event>
  2038.      */
  2039.     public function getEvents(): Collection
  2040.     {
  2041.         return $this->events;
  2042.     }
  2044.     public function addEvent(Event $event): static
  2045.     {
  2046.         if (!$this->events->contains($event)) {
  2047.             $this->events->add($event);
  2048.             $event->setYear($this);
  2049.         }
  2051.         return $this;
  2052.     }
  2054.     public function removeEvent(Event $event): static
  2055.     {
  2056.         if ($this->events->removeElement($event)) {
  2057.             // set the owning side to null (unless already changed)
  2058.             if ($event->getYear() === $this) {
  2059.                 $event->setYear(null);
  2060.             }
  2061.         }
  2063.         return $this;
  2064.     }
  2066.     /**
  2067.      * @return Collection<int, AdmissionLimit>
  2068.      */
  2069.     public function getAdmissionLimits(): Collection
  2070.     {
  2071.         return $this->admissionLimits;
  2072.     }
  2074.     public function addAdmissionLimit(AdmissionLimit $admissionLimit): static
  2075.     {
  2076.         if (!$this->admissionLimits->contains($admissionLimit)) {
  2077.             $this->admissionLimits->add($admissionLimit);
  2078.             $admissionLimit->setYear($this);
  2079.         }
  2081.         return $this;
  2082.     }
  2084.     public function removeAdmissionLimit(AdmissionLimit $admissionLimit): static
  2085.     {
  2086.         if ($this->admissionLimits->removeElement($admissionLimit)) {
  2087.             // set the owning side to null (unless already changed)
  2088.             if ($admissionLimit->getYear() === $this) {
  2089.                 $admissionLimit->setYear(null);
  2090.             }
  2091.         }
  2093.         return $this;
  2094.     }
  2096.     public function getAgendaTimeConvertion(): ?AgendaTimeConvertion
  2097.     {
  2098.         return $this->agendaTimeConvertion;
  2099.     }
  2101.     public function setAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static
  2102.     {
  2103.         // set the owning side of the relation if necessary
  2104.         if ($agendaTimeConvertion->getYear() !== $this) {
  2105.             $agendaTimeConvertion->setYear($this);
  2106.         }
  2108.         $this->agendaTimeConvertion = $agendaTimeConvertion;
  2110.         return $this;
  2111.     }
  2113.     /**
  2114.      * @return Collection<int, ExamWeek>
  2115.      */
  2116.     public function getExamWeeks(): Collection
  2117.     {
  2118.         return $this->examWeeks;
  2119.     }
  2121.     public function addExamWeek(ExamWeek $examWeek): static
  2122.     {
  2123.         if (!$this->examWeeks->contains($examWeek)) {
  2124.             $this->examWeeks->add($examWeek);
  2125.             $examWeek->setYear($this);
  2126.         }
  2128.         return $this;
  2129.     }
  2131.     public function removeExamWeek(ExamWeek $examWeek): static
  2132.     {
  2133.         if ($this->examWeeks->removeElement($examWeek)) {
  2134.             // set the owning side to null (unless already changed)
  2135.             if ($examWeek->getYear() === $this) {
  2136.                 $examWeek->setYear(null);
  2137.             }
  2138.         }
  2140.         return $this;
  2141.     }
  2143.     /**
  2144.      * @return Collection<int, Competence>
  2145.      */
  2146.     public function getCompetences(): Collection
  2147.     {
  2148.         return $this->competences;
  2149.     }
  2151.     public function addCompetence(Competence $competence): static
  2152.     {
  2153.         if (!$this->competences->contains($competence)) {
  2154.             $this->competences->add($competence);
  2155.             $competence->setYear($this);
  2156.         }
  2158.         return $this;
  2159.     }
  2161.     public function removeCompetence(Competence $competence): static
  2162.     {
  2163.         if ($this->competences->removeElement($competence)) {
  2164.             // set the owning side to null (unless already changed)
  2165.             if ($competence->getYear() === $this) {
  2166.                 $competence->setYear(null);
  2167.             }
  2168.         }
  2170.         return $this;
  2171.     }
  2173.     /**
  2174.      * @return Collection<int, WeekSubjectGoal>
  2175.      */
  2176.     public function getWeekSubjectGoals(): Collection
  2177.     {
  2178.         return $this->weekSubjectGoals;
  2179.     }
  2181.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  2182.     {
  2183.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  2184.             $this->weekSubjectGoals->add($weekSubjectGoal);
  2185.             $weekSubjectGoal->setYear($this);
  2186.         }
  2188.         return $this;
  2189.     }
  2191.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  2192.     {
  2193.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  2194.             // set the owning side to null (unless already changed)
  2195.             if ($weekSubjectGoal->getYear() === $this) {
  2196.                 $weekSubjectGoal->setYear(null);
  2197.             }
  2198.         }
  2200.         return $this;
  2201.     }
  2203.     /**
  2204.      * @return Collection<int, ProfSchoolPlanner>
  2205.      */
  2206.     public function getProfSchoolPlanners(): Collection
  2207.     {
  2208.         return $this->profSchoolPlanners;
  2209.     }
  2211.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  2212.     {
  2213.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  2214.             $this->profSchoolPlanners->add($profSchoolPlanner);
  2215.             $profSchoolPlanner->setYear($this);
  2216.         }
  2218.         return $this;
  2219.     }
  2221.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  2222.     {
  2223.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  2224.             // set the owning side to null (unless already changed)
  2225.             if ($profSchoolPlanner->getYear() === $this) {
  2226.                 $profSchoolPlanner->setYear(null);
  2227.             }
  2228.         }
  2230.         return $this;
  2231.     }
  2233.     /**
  2234.      * @return Collection<int, ProfTime>
  2235.      */
  2236.     public function getProfTimes(): Collection
  2237.     {
  2238.         return $this->profTimes;
  2239.     }
  2241.     public function addProfTime(ProfTime $profTime): static
  2242.     {
  2243.         if (!$this->profTimes->contains($profTime)) {
  2244.             $this->profTimes->add($profTime);
  2245.             $profTime->setYear($this);
  2246.         }
  2248.         return $this;
  2249.     }
  2251.     public function removeProfTime(ProfTime $profTime): static
  2252.     {
  2253.         if ($this->profTimes->removeElement($profTime)) {
  2254.             // set the owning side to null (unless already changed)
  2255.             if ($profTime->getYear() === $this) {
  2256.                 $profTime->setYear(null);
  2257.             }
  2258.         }
  2260.         return $this;
  2261.     }
  2263.     /**
  2264.      * @return Collection<int, SchoolPlannerType>
  2265.      */
  2266.     public function getSchoolPlannerTypes(): Collection
  2267.     {
  2268.         return $this->schoolPlannerTypes;
  2269.     }
  2271.     public function addSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static
  2272.     {
  2273.         if (!$this->schoolPlannerTypes->contains($schoolPlannerType)) {
  2274.             $this->schoolPlannerTypes->add($schoolPlannerType);
  2275.             $schoolPlannerType->setYear($this);
  2276.         }
  2278.         return $this;
  2279.     }
  2281.     public function removeSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static
  2282.     {
  2283.         if ($this->schoolPlannerTypes->removeElement($schoolPlannerType)) {
  2284.             // set the owning side to null (unless already changed)
  2285.             if ($schoolPlannerType->getYear() === $this) {
  2286.                 $schoolPlannerType->setYear(null);
  2287.             }
  2288.         }
  2290.         return $this;
  2291.     }
  2293.     /**
  2294.      * @return Collection<int, AgendaElement>
  2295.      */
  2296.     public function getAgendaElements(): Collection
  2297.     {
  2298.         return $this->agendaElements;
  2299.     }
  2301.     public function addAgendaElement(AgendaElement $agendaElement): static
  2302.     {
  2303.         if (!$this->agendaElements->contains($agendaElement)) {
  2304.             $this->agendaElements->add($agendaElement);
  2305.             $agendaElement->setYear($this);
  2306.         }
  2308.         return $this;
  2309.     }
  2311.     public function removeAgendaElement(AgendaElement $agendaElement): static
  2312.     {
  2313.         if ($this->agendaElements->removeElement($agendaElement)) {
  2314.             // set the owning side to null (unless already changed)
  2315.             if ($agendaElement->getYear() === $this) {
  2316.                 $agendaElement->setYear(null);
  2317.             }
  2318.         }
  2320.         return $this;
  2321.     }
  2323.     /**
  2324.      * @return Collection<int, GlobalSchoolBreak>
  2325.      */
  2326.     public function getGlobalSchoolBreaks(): Collection
  2327.     {
  2328.         return $this->globalSchoolBreaks;
  2329.     }
  2331.     public function addGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
  2332.     {
  2333.         if (!$this->globalSchoolBreaks->contains($globalSchoolBreak)) {
  2334.             $this->globalSchoolBreaks->add($globalSchoolBreak);
  2335.             $globalSchoolBreak->setYear($this);
  2336.         }
  2338.         return $this;
  2339.     }
  2341.     public function removeGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static
  2342.     {
  2343.         if ($this->globalSchoolBreaks->removeElement($globalSchoolBreak)) {
  2344.             // set the owning side to null (unless already changed)
  2345.             if ($globalSchoolBreak->getYear() === $this) {
  2346.                 $globalSchoolBreak->setYear(null);
  2347.             }
  2348.         }
  2350.         return $this;
  2351.     }
  2353.     /**
  2354.      * @return Collection<int, TeacherAbsence>
  2355.      */
  2356.     public function getTeacherAbsences(): Collection
  2357.     {
  2358.         return $this->teacherAbsences;
  2359.     }
  2361.     public function addTeacherAbsence(TeacherAbsence $teacherAbsence): static
  2362.     {
  2363.         if (!$this->teacherAbsences->contains($teacherAbsence)) {
  2364.             $this->teacherAbsences->add($teacherAbsence);
  2365.             $teacherAbsence->setYear($this);
  2366.         }
  2368.         return $this;
  2369.     }
  2371.     public function removeTeacherAbsence(TeacherAbsence $teacherAbsence): static
  2372.     {
  2373.         if ($this->teacherAbsences->removeElement($teacherAbsence)) {
  2374.             // set the owning side to null (unless already changed)
  2375.             if ($teacherAbsence->getYear() === $this) {
  2376.                 $teacherAbsence->setYear(null);
  2377.             }
  2378.         }
  2380.         return $this;
  2381.     }
  2383.     /**
  2384.      * @return Collection<int, AttendanceMissed>
  2385.      */
  2386.     public function getAttendanceMisseds(): Collection
  2387.     {
  2388.         return $this->attendanceMisseds;
  2389.     }
  2391.     public function addAttendanceMissed(AttendanceMissed $attendanceMissed): static
  2392.     {
  2393.         if (!$this->attendanceMisseds->contains($attendanceMissed)) {
  2394.             $this->attendanceMisseds->add($attendanceMissed);
  2395.             $attendanceMissed->setYear($this);
  2396.         }
  2398.         return $this;
  2399.     }
  2401.     public function removeAttendanceMissed(AttendanceMissed $attendanceMissed): static
  2402.     {
  2403.         if ($this->attendanceMisseds->removeElement($attendanceMissed)) {
  2404.             // set the owning side to null (unless already changed)
  2405.             if ($attendanceMissed->getYear() === $this) {
  2406.                 $attendanceMissed->setYear(null);
  2407.             }
  2408.         }
  2410.         return $this;
  2411.     }
  2413.     /**
  2414.      * @return Collection<int, GeneralBreak>
  2415.      */
  2416.     public function getGeneralBreaks(): Collection
  2417.     {
  2418.         return $this->generalBreaks;
  2419.     }
  2421.     public function addGeneralBreak(GeneralBreak $generalBreak): static
  2422.     {
  2423.         if (!$this->generalBreaks->contains($generalBreak)) {
  2424.             $this->generalBreaks->add($generalBreak);
  2425.             $generalBreak->setYear($this);
  2426.         }
  2428.         return $this;
  2429.     }
  2431.     public function removeGeneralBreak(GeneralBreak $generalBreak): static
  2432.     {
  2433.         if ($this->generalBreaks->removeElement($generalBreak)) {
  2434.             // set the owning side to null (unless already changed)
  2435.             if ($generalBreak->getYear() === $this) {
  2436.                 $generalBreak->setYear(null);
  2437.             }
  2438.         }
  2440.         return $this;
  2441.     }
  2443.     public function getLevel(): ?int
  2444.     {
  2445.         return $this->level;
  2446.     }
  2448.     public function setLevel(?int $level): static
  2449.     {
  2450.         $this->level = $level;
  2452.         return $this;
  2453.     }
  2454. }