<?phpnamespace App\Entity;use App\Entity\Traits\Timestampable;use App\Repository\SchoolRepository;use Doctrine\Common\Collections\ArrayCollection;use Doctrine\Common\Collections\Collection;use Doctrine\ORM\Mapping as ORM;use JMS\Serializer\Annotation\Groups;#[ORM\HasLifecycleCallbacks]#[ORM\Entity(repositoryClass: SchoolRepository::class)]class School{ use Timestampable; // Valeurs de $type : pilote le menu et le système d'évaluation (séquence vs // sous-matières). ATTENTION : $type est déjà lu (jamais écrit) par des // templates historiques (bulletin/certificate/honnor/_sidebar) qui testent // school.type == 1|2|3|4 pour distinguer Proviseur/Principal, Lycée/Collège — // une distinction jamais branchée à aucun formulaire (setType() n'est appelé // nulle part dans le code actuel). Pour ne RIEN changer à ce comportement // existant (toutes les écoles ont type=null aujourd'hui, donc tombent dans // les branches "else" de ces templates), les valeurs ci-dessous évitent // volontairement la plage 1-4 : une école secondaire/primaire/maternelle // créée via ce nouveau système continue de tomber dans les mêmes branches // "else" qu'avant, à l'identique d'une école avec type=null. public const TYPE_SECONDAIRE = 10; public const TYPE_PRIMAIRE = 20; public const TYPE_MATERNELLE = 30; #[ORM\Id] #[ORM\GeneratedValue] #[ORM\Column] #[Groups(['getStudents','getSubject','getAppUsers','getClass','getAbsence'])] private ?int $id = null; #[ORM\Column(length: 255)] #[Groups(['getStudents','getAbsence'])] private ?string $name = null; #[ORM\Column(length: 255, nullable: true)] private ?string $phone = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: User::class)] private Collection $users; #[ORM\Column(length: 255, nullable: true)] private ?string $email = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: UserYear::class)] private Collection $userYears; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Student::class)] private Collection $students; #[ORM\OneToMany(mappedBy: 'school', targetEntity: StudentYear::class)] private Collection $studentYears; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Absence::class)] private Collection $absences; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Note::class)] private Collection $notes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DocInfo::class)] private Collection $docInfos; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Event::class)] private Collection $events; #[ORM\OneToMany(mappedBy: 'school', targetEntity: HomeWork::class)] private Collection $homeWorks; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Late::class)] private Collection $lates; #[ORM\OneToMany(mappedBy: 'school', targetEntity: HomeWorkYear::class)] private Collection $homeWorkYears; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Punish::class)] private Collection $punishes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PunishCategory::class)] private Collection $punishCategories; #[ORM\OneToMany(mappedBy: 'school', targetEntity: SchoolSection::class)] private Collection $schoolSections; #[ORM\OneToMany(mappedBy: 'school', targetEntity: TheClass::class)] private Collection $theClasses; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Subject::class)] private Collection $subjects; #[ORM\OneToMany(mappedBy: 'school', targetEntity: SubjectGroup::class)] private Collection $subjectGroups; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Discussion::class)] private Collection $discussions; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DiscussionClass::class)] private Collection $discussionClasses; #[ORM\OneToMany(mappedBy: 'school', targetEntity: CategoryEvent::class)] private Collection $categoryEvents; #[ORM\OneToMany(mappedBy: 'school', targetEntity: News::class)] private Collection $news; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Agenda::class)] private Collection $agendas; #[ORM\OneToMany(mappedBy: 'school', targetEntity: ExamAgenda::class)] private Collection $examAgendas; #[ORM\OneToMany(mappedBy: 'School', targetEntity: SubSequence::class, orphanRemoval: true)] private Collection $subSequences; #[ORM\OneToMany(mappedBy: 'school', targetEntity: SubNote::class, orphanRemoval: true)] private Collection $subNotes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GlobalExam::class, orphanRemoval: true)] private Collection $globalExams; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GlobalQuarter::class, orphanRemoval: true)] private Collection $globalQuarters; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Appreciation::class, orphanRemoval: true)] private Collection $appreciations; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Scolarity::class)] private Collection $scolarities; #[ORM\OneToMany(mappedBy: 'school', targetEntity: ScolarityHistory::class)] private Collection $scolarityHistories; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplineWarning::class, orphanRemoval: true)] private Collection $disciplineWarnings; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplineBlame::class, orphanRemoval: true)] private Collection $disciplineBlames; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplineExclusion::class)] private Collection $disciplineExclusions; #[ORM\OneToMany(mappedBy: 'school', targetEntity: ParentNote::class)] private Collection $parentNotes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: JustifyAbsence::class)] private Collection $justifyAbsences; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AbsenceRetainedConfig::class, orphanRemoval: true)] private Collection $absenceRetainedConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AbsenceWarningConfig::class)] private Collection $absenceWarningConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AbsenceExclusionConfig::class)] private Collection $absenceExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AbsenceBlameConfig::class)] private Collection $absenceBlameConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplineRetained::class)] private Collection $disciplineRetaineds; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DefinitiveExclusion::class)] private Collection $definitiveExclusions; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplineConcile::class)] private Collection $disciplineConciles; #[ORM\OneToMany(mappedBy: 'school', targetEntity: RetainedDisciplineConcileConfig::class)] private Collection $retainedDisciplineConcileConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: RetainedBlameConfig::class)] private Collection $retainedBlameConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: RetainedWarningConfig::class)] private Collection $retainedWarningConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: RetainedDefinitiveExclusionConfig::class)] private Collection $retainedDefinitiveExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlameDefinitiveExclusionConfig::class)] private Collection $blameDefinitiveExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlameExclusionConfig::class)] private Collection $blameExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlameWarningConfig::class)] private Collection $blameWarningConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlameRetainedConfig::class)] private Collection $blameRetainedConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlameDisciplineConcileConfig::class)] private Collection $blameDisciplineConcileConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: RetainedExclusionConfig::class)] private Collection $retainedExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: WarningExclusionConfig::class)] private Collection $warningExclusionConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: WarningDefinitiveExclusionConfig::class)] private Collection $warningDefinitiveExclusionConfigs; #[ORM\Column(nullable: true)] private ?int $type = null; #[ORM\Column(length: 255, nullable: true)] private ?string $englishName = null; #[ORM\Column(nullable: true)] private ?int $langage = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PrimaryParentNote::class)] private Collection $primaryParentNotes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PrimaryNote::class)] private Collection $primaryNotes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: VerbalProcessCategory::class)] private Collection $verbalProcessCategories; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GlobalDisciplineConfig::class)] private Collection $globalDisciplineConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: DisciplinePunish::class)] private Collection $disciplinePunishes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GlobalDisciplineEnabledConfig::class)] private Collection $globalDisciplineEnabledConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: BlamePunishConfig::class)] private Collection $blamePunishConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AbsencePunishConfig::class)] private Collection $absencePunishConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: WarningPunishConfig::class)] private Collection $warningPunishConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PunishRetainedConfig::class)] private Collection $punishRetainedConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PunishWarningConfig::class)] private Collection $punishWarningConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PunishBlameConfig::class)] private Collection $punishBlameConfigs; #[ORM\OneToMany(mappedBy: 'school', targetEntity: PunishExclusionConfig::class)] private Collection $punishExclusionConfigs; #[ORM\Column(length: 255, nullable: true)] private ?string $nameEn = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: UserIphoneToken::class)] private Collection $userIphoneTokens; #[ORM\OneToMany(mappedBy: 'school', targetEntity: UserAndroidToken::class)] private Collection $userAndroidTokens; #[ORM\OneToMany(mappedBy: 'school', targetEntity: NewsCategory::class)] private Collection $newsCategories; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Blame::class)] private Collection $blames; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Warning::class)] private Collection $warnings; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Retained::class)] private Collection $retaineds; #[ORM\Column(length: 255, nullable: true)] private ?string $city = null; #[ORM\Column(length: 255, nullable: true)] private ?string $phone1 = null; #[ORM\Column(length: 255, nullable: true)] private ?string $phone2 = null; #[ORM\Column(length: 255, nullable: true)] private ?string $box = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: HonnorTableLimitMoy::class)] private Collection $honnorTableLimitMoys; #[ORM\OneToMany(mappedBy: 'school', targetEntity: SchoolYearInfos::class)] private Collection $schoolYearInfos; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AdmissionLimit::class)] private Collection $admissionLimits; #[ORM\OneToOne(mappedBy: 'school', cascade: ['persist'])] private ?AgendaTimeConvertion $agendaTimeConvertion = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: Competence::class)] private Collection $competences; #[ORM\OneToMany(mappedBy: 'school', targetEntity: WeekSubjectGoal::class)] private Collection $weekSubjectGoals; #[ORM\OneToMany(mappedBy: 'school', targetEntity: ProfSchoolPlanner::class)] private Collection $profSchoolPlanners; #[ORM\OneToMany(mappedBy: 'school', targetEntity: ProfTime::class)] private Collection $profTimes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: SchoolPlannerType::class)] private Collection $schoolPlannerTypes; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AgendaElement::class)] private Collection $agendaElements; #[ORM\Column(length: 255, nullable: true)] private ?string $logo = null; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GlobalSchoolBreak::class)] private Collection $globalSchoolBreaks; #[ORM\OneToMany(mappedBy: 'school', targetEntity: TeacherAbsence::class, orphanRemoval: true)] private Collection $teacherAbsences; #[ORM\OneToMany(mappedBy: 'school', targetEntity: AttendanceMissed::class)] private Collection $attendanceMisseds; #[ORM\OneToMany(mappedBy: 'school', targetEntity: GeneralBreak::class, orphanRemoval: true)] private Collection $generalBreaks; #[ORM\ManyToOne(inversedBy: 'schools')] private ?Region $region = null; #[ORM\ManyToOne(inversedBy: 'schools')] private ?Department $department = null; public function __construct() { $this->users = new ArrayCollection(); $this->userYears = new ArrayCollection(); $this->students = new ArrayCollection(); $this->studentYears = new ArrayCollection(); $this->absences = new ArrayCollection(); $this->notes = new ArrayCollection(); $this->docInfos = new ArrayCollection(); $this->events = new ArrayCollection(); $this->homeWorks = new ArrayCollection(); $this->lates = new ArrayCollection(); $this->homeWorkYears = new ArrayCollection(); $this->punishes = new ArrayCollection(); $this->punishCategories = new ArrayCollection(); $this->schoolSections = new ArrayCollection(); $this->theClasses = new ArrayCollection(); $this->subjects = new ArrayCollection(); $this->subjectGroups = new ArrayCollection(); $this->discussions = new ArrayCollection(); $this->discussionClasses = new ArrayCollection(); $this->categoryEvents = new ArrayCollection(); $this->news = new ArrayCollection(); $this->agendas = new ArrayCollection(); $this->examAgendas = new ArrayCollection(); $this->subSequences = new ArrayCollection(); $this->subNotes = new ArrayCollection(); $this->globalExams = new ArrayCollection(); $this->globalQuarters = new ArrayCollection(); $this->appreciations = new ArrayCollection(); $this->scolarities = new ArrayCollection(); $this->scolarityHistories = new ArrayCollection(); $this->disciplineWarnings = new ArrayCollection(); $this->disciplineBlames = new ArrayCollection(); $this->disciplineExclusions = new ArrayCollection(); $this->parentNotes = new ArrayCollection(); $this->justifyAbsences = new ArrayCollection(); $this->absenceRetainedConfigs = new ArrayCollection(); $this->absenceWarningConfigs = new ArrayCollection(); $this->absenceExclusionConfigs = new ArrayCollection(); $this->absenceBlameConfigs = new ArrayCollection(); $this->disciplineRetaineds = new ArrayCollection(); $this->definitiveExclusions = new ArrayCollection(); $this->disciplineConciles = new ArrayCollection(); $this->retainedDisciplineConcileConfigs = new ArrayCollection(); $this->retainedBlameConfigs = new ArrayCollection(); $this->retainedWarningConfigs = new ArrayCollection(); $this->retainedDefinitiveExclusionConfigs = new ArrayCollection(); $this->blameDefinitiveExclusionConfigs = new ArrayCollection(); $this->blameExclusionConfigs = new ArrayCollection(); $this->blameWarningConfigs = new ArrayCollection(); $this->blameRetainedConfigs = new ArrayCollection(); $this->blameDisciplineConcileConfigs = new ArrayCollection(); $this->retainedExclusionConfigs = new ArrayCollection(); $this->warningExclusionConfigs = new ArrayCollection(); $this->warningDefinitiveExclusionConfigs = new ArrayCollection(); $this->primaryParentNotes = new ArrayCollection(); $this->primaryNotes = new ArrayCollection(); $this->verbalProcessCategories = new ArrayCollection(); $this->globalDisciplineConfigs = new ArrayCollection(); $this->disciplinePunishes = new ArrayCollection(); $this->globalDisciplineEnabledConfigs = new ArrayCollection(); $this->blamePunishConfigs = new ArrayCollection(); $this->absencePunishConfigs = new ArrayCollection(); $this->warningPunishConfigs = new ArrayCollection(); $this->punishRetainedConfigs = new ArrayCollection(); $this->punishWarningConfigs = new ArrayCollection(); $this->punishBlameConfigs = new ArrayCollection(); $this->punishExclusionConfigs = new ArrayCollection(); $this->userIphoneTokens = new ArrayCollection(); $this->userAndroidTokens = new ArrayCollection(); $this->newsCategories = new ArrayCollection(); $this->blames = new ArrayCollection(); $this->warnings = new ArrayCollection(); $this->retaineds = new ArrayCollection(); $this->honnorTableLimitMoys = new ArrayCollection(); $this->schoolYearInfos = new ArrayCollection(); $this->admissionLimits = new ArrayCollection(); $this->competences = new ArrayCollection(); $this->weekSubjectGoals = new ArrayCollection(); $this->profSchoolPlanners = new ArrayCollection(); $this->profTimes = new ArrayCollection(); $this->schoolPlannerTypes = new ArrayCollection(); $this->agendaElements = new ArrayCollection(); $this->globalSchoolBreaks = new ArrayCollection(); $this->teacherAbsences = new ArrayCollection(); $this->attendanceMisseds = new ArrayCollection(); $this->generalBreaks = new ArrayCollection(); } public function getId(): ?int { return $this->id; } public function getName(): ?string { return $this->name; } public function setName(string $name): static { $this->name = $name; return $this; } public function getPhone(): ?string { return $this->phone; } public function setPhone(?string $phone): static { $this->phone = $phone; return $this; } /** * @return Collection<int, User> */ public function getUsers(): Collection { return $this->users; } public function addUser(User $user): static { if (!$this->users->contains($user)) { $this->users->add($user); $user->setSchool($this); } return $this; } public function removeUser(User $user): static { if ($this->users->removeElement($user)) { // set the owning side to null (unless already changed) if ($user->getSchool() === $this) { $user->setSchool(null); } } return $this; } public function getEmail(): ?string { return $this->email; } public function setEmail(?string $email): static { $this->email = $email; return $this; } /** * @return Collection<int, UserYear> */ public function getUserYears(): Collection { return $this->userYears; } public function addUserYear(UserYear $userYear): static { if (!$this->userYears->contains($userYear)) { $this->userYears->add($userYear); $userYear->setSchool($this); } return $this; } public function removeUserYear(UserYear $userYear): static { if ($this->userYears->removeElement($userYear)) { // set the owning side to null (unless already changed) if ($userYear->getSchool() === $this) { $userYear->setSchool(null); } } return $this; } /** * @return Collection<int, Student> */ public function getStudents(): Collection { return $this->students; } public function addStudent(Student $student): static { if (!$this->students->contains($student)) { $this->students->add($student); $student->setSchool($this); } return $this; } public function removeStudent(Student $student): static { if ($this->students->removeElement($student)) { // set the owning side to null (unless already changed) if ($student->getSchool() === $this) { $student->setSchool(null); } } return $this; } /** * @return Collection<int, StudentYear> */ public function getStudentYears(): Collection { return $this->studentYears; } public function addStudentYear(StudentYear $studentYear): static { if (!$this->studentYears->contains($studentYear)) { $this->studentYears->add($studentYear); $studentYear->setSchool($this); } return $this; } public function removeStudentYear(StudentYear $studentYear): static { if ($this->studentYears->removeElement($studentYear)) { // set the owning side to null (unless already changed) if ($studentYear->getSchool() === $this) { $studentYear->setSchool(null); } } return $this; } /** * @return Collection<int, Absence> */ public function getAbsences(): Collection { return $this->absences; } public function addAbsence(Absence $absence): static { if (!$this->absences->contains($absence)) { $this->absences->add($absence); $absence->setSchool($this); } return $this; } public function removeAbsence(Absence $absence): static { if ($this->absences->removeElement($absence)) { // set the owning side to null (unless already changed) if ($absence->getSchool() === $this) { $absence->setSchool(null); } } return $this; } /** * @return Collection<int, Note> */ public function getNotes(): Collection { return $this->notes; } public function addNote(Note $note): static { if (!$this->notes->contains($note)) { $this->notes->add($note); $note->setSchool($this); } return $this; } public function removeNote(Note $note): static { if ($this->notes->removeElement($note)) { // set the owning side to null (unless already changed) if ($note->getSchool() === $this) { $note->setSchool(null); } } return $this; } /** * @return Collection<int, DocInfo> */ public function getDocInfos(): Collection { return $this->docInfos; } public function addDocInfo(DocInfo $docInfo): static { if (!$this->docInfos->contains($docInfo)) { $this->docInfos->add($docInfo); $docInfo->setSchool($this); } return $this; } public function removeDocInfo(DocInfo $docInfo): static { if ($this->docInfos->removeElement($docInfo)) { // set the owning side to null (unless already changed) if ($docInfo->getSchool() === $this) { $docInfo->setSchool(null); } } return $this; } /** * @return Collection<int, Event> */ public function getEvents(): Collection { return $this->events; } public function addEvent(Event $event): static { if (!$this->events->contains($event)) { $this->events->add($event); $event->setSchool($this); } return $this; } public function removeEvent(Event $event): static { if ($this->events->removeElement($event)) { // set the owning side to null (unless already changed) if ($event->getSchool() === $this) { $event->setSchool(null); } } return $this; } /** * @return Collection<int, HomeWork> */ public function getHomeWorks(): Collection { return $this->homeWorks; } public function addHomeWork(HomeWork $homeWork): static { if (!$this->homeWorks->contains($homeWork)) { $this->homeWorks->add($homeWork); $homeWork->setSchool($this); } return $this; } public function removeHomeWork(HomeWork $homeWork): static { if ($this->homeWorks->removeElement($homeWork)) { // set the owning side to null (unless already changed) if ($homeWork->getSchool() === $this) { $homeWork->setSchool(null); } } return $this; } /** * @return Collection<int, Late> */ public function getLates(): Collection { return $this->lates; } public function addLate(Late $late): static { if (!$this->lates->contains($late)) { $this->lates->add($late); $late->setSchool($this); } return $this; } public function removeLate(Late $late): static { if ($this->lates->removeElement($late)) { // set the owning side to null (unless already changed) if ($late->getSchool() === $this) { $late->setSchool(null); } } return $this; } /** * @return Collection<int, HomeWorkYear> */ public function getHomeWorkYears(): Collection { return $this->homeWorkYears; } public function addHomeWorkYear(HomeWorkYear $homeWorkYear): static { if (!$this->homeWorkYears->contains($homeWorkYear)) { $this->homeWorkYears->add($homeWorkYear); $homeWorkYear->setSchool($this); } return $this; } public function removeHomeWorkYear(HomeWorkYear $homeWorkYear): static { if ($this->homeWorkYears->removeElement($homeWorkYear)) { // set the owning side to null (unless already changed) if ($homeWorkYear->getSchool() === $this) { $homeWorkYear->setSchool(null); } } return $this; } /** * @return Collection<int, Punish> */ public function getPunishes(): Collection { return $this->punishes; } public function addPunish(Punish $punish): static { if (!$this->punishes->contains($punish)) { $this->punishes->add($punish); $punish->setSchool($this); } return $this; } public function removePunish(Punish $punish): static { if ($this->punishes->removeElement($punish)) { // set the owning side to null (unless already changed) if ($punish->getSchool() === $this) { $punish->setSchool(null); } } return $this; } /** * @return Collection<int, PunishCategory> */ public function getPunishCategories(): Collection { return $this->punishCategories; } public function addPunishCategory(PunishCategory $punishCategory): static { if (!$this->punishCategories->contains($punishCategory)) { $this->punishCategories->add($punishCategory); $punishCategory->setSchool($this); } return $this; } public function removePunishCategory(PunishCategory $punishCategory): static { if ($this->punishCategories->removeElement($punishCategory)) { // set the owning side to null (unless already changed) if ($punishCategory->getSchool() === $this) { $punishCategory->setSchool(null); } } return $this; } /** * @return Collection<int, SchoolSection> */ public function getSchoolSections(): Collection { return $this->schoolSections; } public function addSchoolSection(SchoolSection $schoolSection): static { if (!$this->schoolSections->contains($schoolSection)) { $this->schoolSections->add($schoolSection); $schoolSection->setSchool($this); } return $this; } public function removeSchoolSection(SchoolSection $schoolSection): static { if ($this->schoolSections->removeElement($schoolSection)) { // set the owning side to null (unless already changed) if ($schoolSection->getSchool() === $this) { $schoolSection->setSchool(null); } } return $this; } /** * @return Collection<int, TheClass> */ public function getTheClasses(): Collection { return $this->theClasses; } public function addTheClass(TheClass $theClass): static { if (!$this->theClasses->contains($theClass)) { $this->theClasses->add($theClass); $theClass->setSchool($this); } return $this; } public function removeTheClass(TheClass $theClass): static { if ($this->theClasses->removeElement($theClass)) { // set the owning side to null (unless already changed) if ($theClass->getSchool() === $this) { $theClass->setSchool(null); } } return $this; } /** * @return Collection<int, Subject> */ public function getSubjects(): Collection { return $this->subjects; } public function addSubject(Subject $subject): static { if (!$this->subjects->contains($subject)) { $this->subjects->add($subject); $subject->setSchool($this); } return $this; } public function removeSubject(Subject $subject): static { if ($this->subjects->removeElement($subject)) { // set the owning side to null (unless already changed) if ($subject->getSchool() === $this) { $subject->setSchool(null); } } return $this; } /** * @return Collection<int, SubjectGroup> */ public function getSubjectGroups(): Collection { return $this->subjectGroups; } public function addSubjectGroup(SubjectGroup $subjectGroup): static { if (!$this->subjectGroups->contains($subjectGroup)) { $this->subjectGroups->add($subjectGroup); $subjectGroup->setSchool($this); } return $this; } public function removeSubjectGroup(SubjectGroup $subjectGroup): static { if ($this->subjectGroups->removeElement($subjectGroup)) { // set the owning side to null (unless already changed) if ($subjectGroup->getSchool() === $this) { $subjectGroup->setSchool(null); } } return $this; } /** * @return Collection<int, Discussion> */ public function getDiscussions(): Collection { return $this->discussions; } public function addDiscussion(Discussion $discussion): static { if (!$this->discussions->contains($discussion)) { $this->discussions->add($discussion); $discussion->setSchool($this); } return $this; } public function removeDiscussion(Discussion $discussion): static { if ($this->discussions->removeElement($discussion)) { // set the owning side to null (unless already changed) if ($discussion->getSchool() === $this) { $discussion->setSchool(null); } } return $this; } /** * @return Collection<int, DiscussionClass> */ public function getDiscussionClasses(): Collection { return $this->discussionClasses; } public function addDiscussionClass(DiscussionClass $discussionClass): static { if (!$this->discussionClasses->contains($discussionClass)) { $this->discussionClasses->add($discussionClass); $discussionClass->setSchool($this); } return $this; } public function removeDiscussionClass(DiscussionClass $discussionClass): static { if ($this->discussionClasses->removeElement($discussionClass)) { // set the owning side to null (unless already changed) if ($discussionClass->getSchool() === $this) { $discussionClass->setSchool(null); } } return $this; } /** * @return Collection<int, CategoryEvent> */ public function getCategoryEvents(): Collection { return $this->categoryEvents; } public function addCategoryEvent(CategoryEvent $categoryEvent): static { if (!$this->categoryEvents->contains($categoryEvent)) { $this->categoryEvents->add($categoryEvent); $categoryEvent->setSchool($this); } return $this; } /* * @return Collection<int, News> */ public function getNews(): Collection { return $this->news; } public function addNews(News $news): static { if (!$this->news->contains($news)) { $this->news->add($news); $news->setSchool($this); } return $this; } public function removeCategoryEvent(CategoryEvent $categoryEvent): static { if ($this->categoryEvents->removeElement($categoryEvent)) { // set the owning side to null (unless already changed) if ($categoryEvent->getSchool() === $this) { $categoryEvent->setSchool(null); } } return $this; } public function removeNews(News $news): static { if ($this->news->removeElement($news)) { // set the owning side to null (unless already changed) if ($news->getSchool() === $this) { $news->setSchool(null); } } return $this; } /** * @return Collection<int, Agenda> */ public function getAgendas(): Collection { return $this->agendas; } public function addAgenda(Agenda $agenda): static { if (!$this->agendas->contains($agenda)) { $this->agendas->add($agenda); $agenda->setSchool($this); } return $this; } public function removeAgenda(Agenda $agenda): static { if ($this->agendas->removeElement($agenda)) { // set the owning side to null (unless already changed) if ($agenda->getSchool() === $this) { $agenda->setSchool(null); } } return $this; } /** * @return Collection<int, ExamAgenda> */ public function getExamAgendas(): Collection { return $this->examAgendas; } public function addExamAgenda(ExamAgenda $examAgenda): static { if (!$this->examAgendas->contains($examAgenda)) { $this->examAgendas->add($examAgenda); $examAgenda->setSchool($this); } return $this; } public function removeExamAgenda(ExamAgenda $examAgenda): static { if ($this->examAgendas->removeElement($examAgenda)) { // set the owning side to null (unless already changed) if ($examAgenda->getSchool() === $this) { $examAgenda->setSchool(null); } } return $this; } /** * @return Collection<int, SubSequence> */ public function getSubSequences(): Collection { return $this->subSequences; } public function addSubSequence(SubSequence $subSequence): static { if (!$this->subSequences->contains($subSequence)) { $this->subSequences->add($subSequence); $subSequence->setSchool($this); } return $this; } public function removeSubSequence(SubSequence $subSequence): static { if ($this->subSequences->removeElement($subSequence)) { // set the owning side to null (unless already changed) if ($subSequence->getSchool() === $this) { $subSequence->setSchool(null); } } return $this; } /** * @return Collection<int, SubNote> */ public function getSubNotes(): Collection { return $this->subNotes; } public function addSubNote(SubNote $subNote): static { if (!$this->subNotes->contains($subNote)) { $this->subNotes->add($subNote); $subNote->setSchool($this); } return $this; } public function removeSubNote(SubNote $subNote): static { if ($this->subNotes->removeElement($subNote)) { // set the owning side to null (unless already changed) if ($subNote->getSchool() === $this) { $subNote->setSchool(null); } } return $this; } /** * @return Collection<int, GlobalExam> */ public function getGlobalExams(): Collection { return $this->globalExams; } public function addGlobalExam(GlobalExam $globalExam): static { if (!$this->globalExams->contains($globalExam)) { $this->globalExams->add($globalExam); $globalExam->setSchool($this); } return $this; } public function removeGlobalExam(GlobalExam $globalExam): static { if ($this->globalExams->removeElement($globalExam)) { // set the owning side to null (unless already changed) if ($globalExam->getSchool() === $this) { $globalExam->setSchool(null); } } return $this; } /** * @return Collection<int, GlobalQuarter> */ public function getGlobalQuarters(): Collection { return $this->globalQuarters; } public function addGlobalQuarter(GlobalQuarter $globalQuarter): static { if (!$this->globalQuarters->contains($globalQuarter)) { $this->globalQuarters->add($globalQuarter); $globalQuarter->setSchool($this); } return $this; } public function removeGlobalQuarter(GlobalQuarter $globalQuarter): static { if ($this->globalQuarters->removeElement($globalQuarter)) { // set the owning side to null (unless already changed) if ($globalQuarter->getSchool() === $this) { $globalQuarter->setSchool(null); } } return $this; } /** * @return Collection<int, Appreciation> */ public function getAppreciations(): Collection { return $this->appreciations; } public function addAppreciation(Appreciation $appreciation): static { if (!$this->appreciations->contains($appreciation)) { $this->appreciations->add($appreciation); $appreciation->setSchool($this); } return $this; } public function removeAppreciation(Appreciation $appreciation): static { if ($this->appreciations->removeElement($appreciation)) { // set the owning side to null (unless already changed) if ($appreciation->getSchool() === $this) { $appreciation->setSchool(null); } } return $this; } /** * @return Collection<int, Scolarity> */ public function getScolarities(): Collection { return $this->scolarities; } public function addScolarity(Scolarity $scolarity): static { if (!$this->scolarities->contains($scolarity)) { $this->scolarities->add($scolarity); $scolarity->setSchool($this); } return $this; } public function removeScolarity(Scolarity $scolarity): static { if ($this->scolarities->removeElement($scolarity)) { // set the owning side to null (unless already changed) if ($scolarity->getSchool() === $this) { $scolarity->setSchool(null); } } return $this; } /** * @return Collection<int, ScolarityHistory> */ public function getScolarityHistories(): Collection { return $this->scolarityHistories; } public function addScolarityHistory(ScolarityHistory $scolarityHistory): static { if (!$this->scolarityHistories->contains($scolarityHistory)) { $this->scolarityHistories->add($scolarityHistory); $scolarityHistory->setSchool($this); } return $this; } public function removeScolarityHistory(ScolarityHistory $scolarityHistory): static { if ($this->scolarityHistories->removeElement($scolarityHistory)) { // set the owning side to null (unless already changed) if ($scolarityHistory->getSchool() === $this) { $scolarityHistory->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplineWarning> */ public function getDisciplineWarnings(): Collection { return $this->disciplineWarnings; } public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static { if (!$this->disciplineWarnings->contains($disciplineWarning)) { $this->disciplineWarnings->add($disciplineWarning); $disciplineWarning->setSchool($this); } return $this; } public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static { if ($this->disciplineWarnings->removeElement($disciplineWarning)) { // set the owning side to null (unless already changed) if ($disciplineWarning->getSchool() === $this) { $disciplineWarning->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplineBlame> */ public function getDisciplineBlames(): Collection { return $this->disciplineBlames; } public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static { if (!$this->disciplineBlames->contains($disciplineBlame)) { $this->disciplineBlames->add($disciplineBlame); $disciplineBlame->setSchool($this); } return $this; } public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static { if ($this->disciplineBlames->removeElement($disciplineBlame)) { // set the owning side to null (unless already changed) if ($disciplineBlame->getSchool() === $this) { $disciplineBlame->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplineExclusion> */ public function getDisciplineExclusions(): Collection { return $this->disciplineExclusions; } public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static { if (!$this->disciplineExclusions->contains($disciplineExclusion)) { $this->disciplineExclusions->add($disciplineExclusion); $disciplineExclusion->setSchool($this); } return $this; } public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static { if ($this->disciplineExclusions->removeElement($disciplineExclusion)) { // set the owning side to null (unless already changed) if ($disciplineExclusion->getSchool() === $this) { $disciplineExclusion->setSchool(null); } } return $this; } /** * @return Collection<int, ParentNote> */ public function getParentNotes(): Collection { return $this->parentNotes; } public function addParentNote(ParentNote $parentNote): static { if (!$this->parentNotes->contains($parentNote)) { $this->parentNotes->add($parentNote); $parentNote->setSchool($this); } return $this; } public function removeParentNote(ParentNote $parentNote): static { if ($this->parentNotes->removeElement($parentNote)) { // set the owning side to null (unless already changed) if ($parentNote->getSchool() === $this) { $parentNote->setSchool(null); } } return $this; } /** * @return Collection<int, JustifyAbsence> */ public function getJustifyAbsences(): Collection { return $this->justifyAbsences; } public function addJustifyAbsence(JustifyAbsence $justifyAbsence): static { if (!$this->justifyAbsences->contains($justifyAbsence)) { $this->justifyAbsences->add($justifyAbsence); $justifyAbsence->setSchool($this); } return $this; } public function removeJustifyAbsence(JustifyAbsence $justifyAbsence): static { if ($this->justifyAbsences->removeElement($justifyAbsence)) { // set the owning side to null (unless already changed) if ($justifyAbsence->getSchool() === $this) { $justifyAbsence->setSchool(null); } } return $this; } /** * @return Collection<int, AbsenceRetainedConfig> */ public function getAbsenceRetainedConfigs(): Collection { return $this->absenceRetainedConfigs; } public function addAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static { if (!$this->absenceRetainedConfigs->contains($absenceRetainedConfig)) { $this->absenceRetainedConfigs->add($absenceRetainedConfig); $absenceRetainedConfig->setSchool($this); } return $this; } public function removeAbsenceRetainedConfig(AbsenceRetainedConfig $absenceRetainedConfig): static { if ($this->absenceRetainedConfigs->removeElement($absenceRetainedConfig)) { // set the owning side to null (unless already changed) if ($absenceRetainedConfig->getSchool() === $this) { $absenceRetainedConfig->setSchool(null); } } return $this; } /** * @return Collection<int, AbsenceWarningConfig> */ public function getAbsenceWarningConfigs(): Collection { return $this->absenceWarningConfigs; } public function addAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static { if (!$this->absenceWarningConfigs->contains($absenceWarningConfig)) { $this->absenceWarningConfigs->add($absenceWarningConfig); $absenceWarningConfig->setSchool($this); } return $this; } public function removeAbsenceWarningConfig(AbsenceWarningConfig $absenceWarningConfig): static { if ($this->absenceWarningConfigs->removeElement($absenceWarningConfig)) { // set the owning side to null (unless already changed) if ($absenceWarningConfig->getSchool() === $this) { $absenceWarningConfig->setSchool(null); } } return $this; } /** * @return Collection<int, AbsenceExclusionConfig> */ public function getAbsenceExclusionConfigs(): Collection { return $this->absenceExclusionConfigs; } public function addAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static { if (!$this->absenceExclusionConfigs->contains($absenceExclusionConfig)) { $this->absenceExclusionConfigs->add($absenceExclusionConfig); $absenceExclusionConfig->setSchool($this); } return $this; } public function removeAbsenceExclusionConfig(AbsenceExclusionConfig $absenceExclusionConfig): static { if ($this->absenceExclusionConfigs->removeElement($absenceExclusionConfig)) { // set the owning side to null (unless already changed) if ($absenceExclusionConfig->getSchool() === $this) { $absenceExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, AbsenceBlameConfig> */ public function getAbsenceBlameConfigs(): Collection { return $this->absenceBlameConfigs; } public function addAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static { if (!$this->absenceBlameConfigs->contains($absenceBlameConfig)) { $this->absenceBlameConfigs->add($absenceBlameConfig); $absenceBlameConfig->setSchool($this); } return $this; } public function removeAbsenceBlameConfig(AbsenceBlameConfig $absenceBlameConfig): static { if ($this->absenceBlameConfigs->removeElement($absenceBlameConfig)) { // set the owning side to null (unless already changed) if ($absenceBlameConfig->getSchool() === $this) { $absenceBlameConfig->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplineRetained> */ public function getDisciplineRetaineds(): Collection { return $this->disciplineRetaineds; } public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static { if (!$this->disciplineRetaineds->contains($disciplineRetained)) { $this->disciplineRetaineds->add($disciplineRetained); $disciplineRetained->setSchool($this); } return $this; } public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static { if ($this->disciplineRetaineds->removeElement($disciplineRetained)) { // set the owning side to null (unless already changed) if ($disciplineRetained->getSchool() === $this) { $disciplineRetained->setSchool(null); } } return $this; } /** * @return Collection<int, DefinitiveExclusion> */ public function getDefinitiveExclusions(): Collection { return $this->definitiveExclusions; } public function addDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static { if (!$this->definitiveExclusions->contains($definitiveExclusion)) { $this->definitiveExclusions->add($definitiveExclusion); $definitiveExclusion->setSchool($this); } return $this; } public function removeDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static { if ($this->definitiveExclusions->removeElement($definitiveExclusion)) { // set the owning side to null (unless already changed) if ($definitiveExclusion->getSchool() === $this) { $definitiveExclusion->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplineConcile> */ public function getDisciplineConciles(): Collection { return $this->disciplineConciles; } public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static { if (!$this->disciplineConciles->contains($disciplineConcile)) { $this->disciplineConciles->add($disciplineConcile); $disciplineConcile->setSchool($this); } return $this; } public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static { if ($this->disciplineConciles->removeElement($disciplineConcile)) { // set the owning side to null (unless already changed) if ($disciplineConcile->getSchool() === $this) { $disciplineConcile->setSchool(null); } } return $this; } /** * @return Collection<int, RetainedDisciplineConcileConfig> */ public function getRetainedDisciplineConcileConfigs(): Collection { return $this->retainedDisciplineConcileConfigs; } public function addRetainedDisciplineConcileConfig(RetainedDisciplineConcileConfig $retainedDisciplineConcileConfig): static { if (!$this->retainedDisciplineConcileConfigs->contains($retainedDisciplineConcileConfig)) { $this->retainedDisciplineConcileConfigs->add($retainedDisciplineConcileConfig); $retainedDisciplineConcileConfig->setSchool($this); } return $this; } public function removeRetainedDisciplineConcileConfig(RetainedDisciplineConcileConfig $retainedDisciplineConcileConfig): static { if ($this->retainedDisciplineConcileConfigs->removeElement($retainedDisciplineConcileConfig)) { // set the owning side to null (unless already changed) if ($retainedDisciplineConcileConfig->getSchool() === $this) { $retainedDisciplineConcileConfig->setSchool(null); } } return $this; } /** * @return Collection<int, RetainedBlameConfig> */ public function getRetainedBlameConfigs(): Collection { return $this->retainedBlameConfigs; } public function addRetainedBlameConfig(RetainedBlameConfig $retainedBlameConfig): static { if (!$this->retainedBlameConfigs->contains($retainedBlameConfig)) { $this->retainedBlameConfigs->add($retainedBlameConfig); $retainedBlameConfig->setSchool($this); } return $this; } public function removeRetainedBlameConfig(RetainedBlameConfig $retainedBlameConfig): static { if ($this->retainedBlameConfigs->removeElement($retainedBlameConfig)) { // set the owning side to null (unless already changed) if ($retainedBlameConfig->getSchool() === $this) { $retainedBlameConfig->setSchool(null); } } return $this; } /** * @return Collection<int, RetainedWarningConfig> */ public function getRetainedWarningConfigs(): Collection { return $this->retainedWarningConfigs; } public function addRetainedWarningConfig(RetainedWarningConfig $retainedWarningConfig): static { if (!$this->retainedWarningConfigs->contains($retainedWarningConfig)) { $this->retainedWarningConfigs->add($retainedWarningConfig); $retainedWarningConfig->setSchool($this); } return $this; } public function removeRetainedWarningConfig(RetainedWarningConfig $retainedWarningConfig): static { if ($this->retainedWarningConfigs->removeElement($retainedWarningConfig)) { // set the owning side to null (unless already changed) if ($retainedWarningConfig->getSchool() === $this) { $retainedWarningConfig->setSchool(null); } } return $this; } /** * @return Collection<int, RetainedDefinitiveExclusionConfig> */ public function getRetainedDefinitiveExclusionConfigs(): Collection { return $this->retainedDefinitiveExclusionConfigs; } public function addRetainedDefinitiveExclusionConfig(RetainedDefinitiveExclusionConfig $retainedDefinitiveExclusionConfig): static { if (!$this->retainedDefinitiveExclusionConfigs->contains($retainedDefinitiveExclusionConfig)) { $this->retainedDefinitiveExclusionConfigs->add($retainedDefinitiveExclusionConfig); $retainedDefinitiveExclusionConfig->setSchool($this); } return $this; } public function removeRetainedDefinitiveExclusionConfig(RetainedDefinitiveExclusionConfig $retainedDefinitiveExclusionConfig): static { if ($this->retainedDefinitiveExclusionConfigs->removeElement($retainedDefinitiveExclusionConfig)) { // set the owning side to null (unless already changed) if ($retainedDefinitiveExclusionConfig->getSchool() === $this) { $retainedDefinitiveExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlameDefinitiveExclusionConfig> */ public function getBlameDefinitiveExclusionConfigs(): Collection { return $this->blameDefinitiveExclusionConfigs; } public function addBlameDefinitiveExclusionConfig(BlameDefinitiveExclusionConfig $blameDefinitiveExclusionConfig): static { if (!$this->blameDefinitiveExclusionConfigs->contains($blameDefinitiveExclusionConfig)) { $this->blameDefinitiveExclusionConfigs->add($blameDefinitiveExclusionConfig); $blameDefinitiveExclusionConfig->setSchool($this); } return $this; } public function removeBlameDefinitiveExclusionConfig(BlameDefinitiveExclusionConfig $blameDefinitiveExclusionConfig): static { if ($this->blameDefinitiveExclusionConfigs->removeElement($blameDefinitiveExclusionConfig)) { // set the owning side to null (unless already changed) if ($blameDefinitiveExclusionConfig->getSchool() === $this) { $blameDefinitiveExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlameExclusionConfig> */ public function getBlameExclusionConfigs(): Collection { return $this->blameExclusionConfigs; } public function addBlameExclusionConfig(BlameExclusionConfig $blameExclusionConfig): static { if (!$this->blameExclusionConfigs->contains($blameExclusionConfig)) { $this->blameExclusionConfigs->add($blameExclusionConfig); $blameExclusionConfig->setSchool($this); } return $this; } public function removeBlameExclusionConfig(BlameExclusionConfig $blameExclusionConfig): static { if ($this->blameExclusionConfigs->removeElement($blameExclusionConfig)) { // set the owning side to null (unless already changed) if ($blameExclusionConfig->getSchool() === $this) { $blameExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlameWarningConfig> */ public function getBlameWarningConfigs(): Collection { return $this->blameWarningConfigs; } public function addBlameWarningConfig(BlameWarningConfig $blameWarningConfig): static { if (!$this->blameWarningConfigs->contains($blameWarningConfig)) { $this->blameWarningConfigs->add($blameWarningConfig); $blameWarningConfig->setSchool($this); } return $this; } public function removeBlameWarningConfig(BlameWarningConfig $blameWarningConfig): static { if ($this->blameWarningConfigs->removeElement($blameWarningConfig)) { // set the owning side to null (unless already changed) if ($blameWarningConfig->getSchool() === $this) { $blameWarningConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlameRetainedConfig> */ public function getBlameRetainedConfigs(): Collection { return $this->blameRetainedConfigs; } public function addBlameRetainedConfig(BlameRetainedConfig $blameRetainedConfig): static { if (!$this->blameRetainedConfigs->contains($blameRetainedConfig)) { $this->blameRetainedConfigs->add($blameRetainedConfig); $blameRetainedConfig->setSchool($this); } return $this; } public function removeBlameRetainedConfig(BlameRetainedConfig $blameRetainedConfig): static { if ($this->blameRetainedConfigs->removeElement($blameRetainedConfig)) { // set the owning side to null (unless already changed) if ($blameRetainedConfig->getSchool() === $this) { $blameRetainedConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlameDisciplineConcileConfig> */ public function getBlameDisciplineConcileConfigs(): Collection { return $this->blameDisciplineConcileConfigs; } public function addBlameDisciplineConcileConfig(BlameDisciplineConcileConfig $blameDisciplineConcileConfig): static { if (!$this->blameDisciplineConcileConfigs->contains($blameDisciplineConcileConfig)) { $this->blameDisciplineConcileConfigs->add($blameDisciplineConcileConfig); $blameDisciplineConcileConfig->setSchool($this); } return $this; } public function removeBlameDisciplineConcileConfig(BlameDisciplineConcileConfig $blameDisciplineConcileConfig): static { if ($this->blameDisciplineConcileConfigs->removeElement($blameDisciplineConcileConfig)) { // set the owning side to null (unless already changed) if ($blameDisciplineConcileConfig->getSchool() === $this) { $blameDisciplineConcileConfig->setSchool(null); } } return $this; } /** * @return Collection<int, RetainedExclusionConfig> */ public function getRetainedExclusionConfigs(): Collection { return $this->retainedExclusionConfigs; } public function addRetainedExclusionConfig(RetainedExclusionConfig $retainedExclusionConfig): static { if (!$this->retainedExclusionConfigs->contains($retainedExclusionConfig)) { $this->retainedExclusionConfigs->add($retainedExclusionConfig); $retainedExclusionConfig->setSchool($this); } return $this; } public function removeRetainedExclusionConfig(RetainedExclusionConfig $retainedExclusionConfig): static { if ($this->retainedExclusionConfigs->removeElement($retainedExclusionConfig)) { // set the owning side to null (unless already changed) if ($retainedExclusionConfig->getSchool() === $this) { $retainedExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, WarningExclusionConfig> */ public function getWarningExclusionConfigs(): Collection { return $this->warningExclusionConfigs; } public function addWarningExclusionConfig(WarningExclusionConfig $warningExclusionConfig): static { if (!$this->warningExclusionConfigs->contains($warningExclusionConfig)) { $this->warningExclusionConfigs->add($warningExclusionConfig); $warningExclusionConfig->setSchool($this); } return $this; } public function removeWarningExclusionConfig(WarningExclusionConfig $warningExclusionConfig): static { if ($this->warningExclusionConfigs->removeElement($warningExclusionConfig)) { // set the owning side to null (unless already changed) if ($warningExclusionConfig->getSchool() === $this) { $warningExclusionConfig->setSchool(null); } } return $this; } /** * @return Collection<int, WarningDefinitiveExclusionConfig> */ public function getWarningDefinitiveExclusionConfigs(): Collection { return $this->warningDefinitiveExclusionConfigs; } public function addWarningDefinitiveExclusionConfig(WarningDefinitiveExclusionConfig $warningDefinitiveExclusionConfig): static { if (!$this->warningDefinitiveExclusionConfigs->contains($warningDefinitiveExclusionConfig)) { $this->warningDefinitiveExclusionConfigs->add($warningDefinitiveExclusionConfig); $warningDefinitiveExclusionConfig->setSchool($this); } return $this; } public function removeWarningDefinitiveExclusionConfig(WarningDefinitiveExclusionConfig $warningDefinitiveExclusionConfig): static { if ($this->warningDefinitiveExclusionConfigs->removeElement($warningDefinitiveExclusionConfig)) { // set the owning side to null (unless already changed) if ($warningDefinitiveExclusionConfig->getSchool() === $this) { $warningDefinitiveExclusionConfig->setSchool(null); } } return $this; } public function getType(): ?int { return $this->type; } public function setType(?int $type): static { $this->type = $type; return $this; } public function isSecondaire(): bool { return $this->type === null || $this->type === self::TYPE_SECONDAIRE; } public function isPrimaryOrKindergarten(): bool { return in_array($this->type, [self::TYPE_PRIMAIRE, self::TYPE_MATERNELLE], true); } /** * Type effectif de l'école — secondaire par défaut si jamais défini * (toute école existante avant School::$type). Centralise la même * convention que isSecondaire()/isPrimaryOrKindergarten() pour le code * qui a besoin de la valeur exacte (ex: CycleLevelRepository::findBySchoolType()). */ public function getEffectiveType(): int { return $this->type ?? self::TYPE_SECONDAIRE; } public function getEnglishName(): ?string { return $this->englishName; } public function setEnglishName(?string $englishName): static { $this->englishName = $englishName; return $this; } public function getLangage(): ?int { return $this->langage; } public function setLangage(?int $langage): static { $this->langage = $langage; return $this; } /** * @return Collection<int, PrimaryParentNote> */ public function getPrimaryParentNotes(): Collection { return $this->primaryParentNotes; } public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static { if (!$this->primaryParentNotes->contains($primaryParentNote)) { $this->primaryParentNotes->add($primaryParentNote); $primaryParentNote->setSchool($this); } return $this; } public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static { if ($this->primaryParentNotes->removeElement($primaryParentNote)) { // set the owning side to null (unless already changed) if ($primaryParentNote->getSchool() === $this) { $primaryParentNote->setSchool(null); } } return $this; } /** * @return Collection<int, PrimaryNote> */ public function getPrimaryNotes(): Collection { return $this->primaryNotes; } public function addPrimaryNote(PrimaryNote $primaryNote): static { if (!$this->primaryNotes->contains($primaryNote)) { $this->primaryNotes->add($primaryNote); $primaryNote->setSchool($this); } return $this; } public function removePrimaryNote(PrimaryNote $primaryNote): static { if ($this->primaryNotes->removeElement($primaryNote)) { // set the owning side to null (unless already changed) if ($primaryNote->getSchool() === $this) { $primaryNote->setSchool(null); } } return $this; } /** * @return Collection<int, VerbalProcessCategory> */ public function getVerbalProcessCategories(): Collection { return $this->verbalProcessCategories; } public function addVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static { if (!$this->verbalProcessCategories->contains($verbalProcessCategory)) { $this->verbalProcessCategories->add($verbalProcessCategory); $verbalProcessCategory->setSchool($this); } return $this; } public function removeVerbalProcessCategory(VerbalProcessCategory $verbalProcessCategory): static { if ($this->verbalProcessCategories->removeElement($verbalProcessCategory)) { // set the owning side to null (unless already changed) if ($verbalProcessCategory->getSchool() === $this) { $verbalProcessCategory->setSchool(null); } } return $this; } /** * @return Collection<int, GlobalDisciplineConfig> */ public function getGlobalDisciplineConfigs(): Collection { return $this->globalDisciplineConfigs; } public function addGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static { if (!$this->globalDisciplineConfigs->contains($globalDisciplineConfig)) { $this->globalDisciplineConfigs->add($globalDisciplineConfig); $globalDisciplineConfig->setSchool($this); } return $this; } public function removeGlobalDisciplineConfig(GlobalDisciplineConfig $globalDisciplineConfig): static { if ($this->globalDisciplineConfigs->removeElement($globalDisciplineConfig)) { // set the owning side to null (unless already changed) if ($globalDisciplineConfig->getSchool() === $this) { $globalDisciplineConfig->setSchool(null); } } return $this; } /** * @return Collection<int, DisciplinePunish> */ public function getDisciplinePunishes(): Collection { return $this->disciplinePunishes; } public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static { if (!$this->disciplinePunishes->contains($disciplinePunish)) { $this->disciplinePunishes->add($disciplinePunish); $disciplinePunish->setSchool($this); } return $this; } public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static { if ($this->disciplinePunishes->removeElement($disciplinePunish)) { // set the owning side to null (unless already changed) if ($disciplinePunish->getSchool() === $this) { $disciplinePunish->setSchool(null); } } return $this; } /** * @return Collection<int, GlobalDisciplineEnabledConfig> */ public function getGlobalDisciplineEnabledConfigs(): Collection { return $this->globalDisciplineEnabledConfigs; } public function addGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static { if (!$this->globalDisciplineEnabledConfigs->contains($globalDisciplineEnabledConfig)) { $this->globalDisciplineEnabledConfigs->add($globalDisciplineEnabledConfig); $globalDisciplineEnabledConfig->setSchool($this); } return $this; } public function removeGlobalDisciplineEnabledConfig(GlobalDisciplineEnabledConfig $globalDisciplineEnabledConfig): static { if ($this->globalDisciplineEnabledConfigs->removeElement($globalDisciplineEnabledConfig)) { // set the owning side to null (unless already changed) if ($globalDisciplineEnabledConfig->getSchool() === $this) { $globalDisciplineEnabledConfig->setSchool(null); } } return $this; } /** * @return Collection<int, BlamePunishConfig> */ public function getBlamePunishConfigs(): Collection { return $this->blamePunishConfigs; } public function addBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static { if (!$this->blamePunishConfigs->contains($blamePunishConfig)) { $this->blamePunishConfigs->add($blamePunishConfig); $blamePunishConfig->setSchool($this); } return $this; } public function removeBlamePunishConfig(BlamePunishConfig $blamePunishConfig): static { if ($this->blamePunishConfigs->removeElement($blamePunishConfig)) { // set the owning side to null (unless already changed) if ($blamePunishConfig->getSchool() === $this) { $blamePunishConfig->setSchool(null); } } return $this; } /** * @return Collection<int, AbsencePunishConfig> */ public function getAbsencePunishConfigs(): Collection { return $this->absencePunishConfigs; } public function addAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static { if (!$this->absencePunishConfigs->contains($absencePunishConfig)) { $this->absencePunishConfigs->add($absencePunishConfig); $absencePunishConfig->setSchool($this); } return $this; } public function removeAbsencePunishConfig(AbsencePunishConfig $absencePunishConfig): static { if ($this->absencePunishConfigs->removeElement($absencePunishConfig)) { // set the owning side to null (unless already changed) if ($absencePunishConfig->getSchool() === $this) { $absencePunishConfig->setSchool(null); } } return $this; } /** * @return Collection<int, WarningPunishConfig> */ public function getWarningPunishConfigs(): Collection { return $this->warningPunishConfigs; } public function addWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static { if (!$this->warningPunishConfigs->contains($warningPunishConfig)) { $this->warningPunishConfigs->add($warningPunishConfig); $warningPunishConfig->setSchool($this); } return $this; } public function removeWarningPunishConfig(WarningPunishConfig $warningPunishConfig): static { if ($this->warningPunishConfigs->removeElement($warningPunishConfig)) { // set the owning side to null (unless already changed) if ($warningPunishConfig->getSchool() === $this) { $warningPunishConfig->setSchool(null); } } return $this; } /** * @return Collection<int, PunishRetainedConfig> */ public function getPunishRetainedConfigs(): Collection { return $this->punishRetainedConfigs; } public function addPunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static { if (!$this->punishRetainedConfigs->contains($punishRetainedConfig)) { $this->punishRetainedConfigs->add($punishRetainedConfig); $punishRetainedConfig->setSchool($this); } return $this; } public function removePunishRetainedConfig(PunishRetainedConfig $punishRetainedConfig): static { if ($this->punishRetainedConfigs->removeElement($punishRetainedConfig)) { // set the owning side to null (unless already changed) if ($punishRetainedConfig->getSchool() === $this) { $punishRetainedConfig->setSchool(null); } } return $this; } /** * @return Collection<int, PunishWarningConfig> */ public function getPunishWarningConfigs(): Collection { return $this->punishWarningConfigs; } public function addPunishWarningConfig(PunishWarningConfig $punishWarningConfig): static { if (!$this->punishWarningConfigs->contains($punishWarningConfig)) { $this->punishWarningConfigs->add($punishWarningConfig); $punishWarningConfig->setSchool($this); } return $this; } public function removePunishWarningConfig(PunishWarningConfig $punishWarningConfig): static { if ($this->punishWarningConfigs->removeElement($punishWarningConfig)) { // set the owning side to null (unless already changed) if ($punishWarningConfig->getSchool() === $this) { $punishWarningConfig->setSchool(null); } } return $this; } /** * @return Collection<int, PunishBlameConfig> */ public function getPunishBlameConfigs(): Collection { return $this->punishBlameConfigs; } public function addPunishBlameConfig(PunishBlameConfig $punishBlameConfig): static { if (!$this->punishBlameConfigs->contains($punishBlameConfig)) { $this->punishBlameConfigs->add($punishBlameConfig); $punishBlameConfig->setSchool($this); } return $this; } public function removePunishBlameConfig(PunishBlameConfig $punishBlameConfig): static { if ($this->punishBlameConfigs->removeElement($punishBlameConfig)) { // set the owning side to null (unless already changed) if ($punishBlameConfig->getSchool() === $this) { $punishBlameConfig->setSchool(null); } } return $this; } /** * @return Collection<int, PunishExclusionConfig> */ public function getPunishExclusionConfigs(): Collection { return $this->punishExclusionConfigs; } public function addPunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static { if (!$this->punishExclusionConfigs->contains($punishExclusionConfig)) { $this->punishExclusionConfigs->add($punishExclusionConfig); $punishExclusionConfig->setSchool($this); } return $this; } public function removePunishExclusionConfig(PunishExclusionConfig $punishExclusionConfig): static { if ($this->punishExclusionConfigs->removeElement($punishExclusionConfig)) { // set the owning side to null (unless already changed) if ($punishExclusionConfig->getSchool() === $this) { $punishExclusionConfig->setSchool(null); } } return $this; } public function getNameEn(): ?string { return $this->nameEn; } public function setNameEn(?string $nameEn): static { $this->nameEn = $nameEn; return $this; } /** * @return Collection<int, UserIphoneToken> */ public function getUserIphoneTokens(): Collection { return $this->userIphoneTokens; } public function addUserIphoneToken(UserIphoneToken $userIphoneToken): static { if (!$this->userIphoneTokens->contains($userIphoneToken)) { $this->userIphoneTokens->add($userIphoneToken); $userIphoneToken->setSchool($this); } return $this; } public function removeUserIphoneToken(UserIphoneToken $userIphoneToken): static { if ($this->userIphoneTokens->removeElement($userIphoneToken)) { // set the owning side to null (unless already changed) if ($userIphoneToken->getSchool() === $this) { $userIphoneToken->setSchool(null); } } return $this; } /** * @return Collection<int, UserAndroidToken> */ public function getUserAndroidTokens(): Collection { return $this->userAndroidTokens; } public function addUserAndroidToken(UserAndroidToken $userAndroidToken): static { if (!$this->userAndroidTokens->contains($userAndroidToken)) { $this->userAndroidTokens->add($userAndroidToken); $userAndroidToken->setSchool($this); } return $this; } public function removeUserAndroidToken(UserAndroidToken $userAndroidToken): static { if ($this->userAndroidTokens->removeElement($userAndroidToken)) { // set the owning side to null (unless already changed) if ($userAndroidToken->getSchool() === $this) { $userAndroidToken->setSchool(null); } } return $this; } /** * @return Collection<int, NewsCategory> */ public function getNewsCategories(): Collection { return $this->newsCategories; } public function addNewsCategory(NewsCategory $newsCategory): static { if (!$this->newsCategories->contains($newsCategory)) { $this->newsCategories->add($newsCategory); $newsCategory->setSchool($this); } return $this; } public function removeNewsCategory(NewsCategory $newsCategory): static { if ($this->newsCategories->removeElement($newsCategory)) { // set the owning side to null (unless already changed) if ($newsCategory->getSchool() === $this) { $newsCategory->setSchool(null); } } return $this; } /** * @return Collection<int, Blame> */ public function getBlames(): Collection { return $this->blames; } public function addBlame(Blame $blame): static { if (!$this->blames->contains($blame)) { $this->blames->add($blame); $blame->setSchool($this); } return $this; } public function removeBlame(Blame $blame): static { if ($this->blames->removeElement($blame)) { // set the owning side to null (unless already changed) if ($blame->getSchool() === $this) { $blame->setSchool(null); } } return $this; } /** * @return Collection<int, Warning> */ public function getWarnings(): Collection { return $this->warnings; } public function addWarning(Warning $warning): static { if (!$this->warnings->contains($warning)) { $this->warnings->add($warning); $warning->setSchool($this); } return $this; } public function removeWarning(Warning $warning): static { if ($this->warnings->removeElement($warning)) { // set the owning side to null (unless already changed) if ($warning->getSchool() === $this) { $warning->setSchool(null); } } return $this; } /** * @return Collection<int, Retained> */ public function getRetaineds(): Collection { return $this->retaineds; } public function addRetained(Retained $retained): static { if (!$this->retaineds->contains($retained)) { $this->retaineds->add($retained); $retained->setSchool($this); } return $this; } public function removeRetained(Retained $retained): static { if ($this->retaineds->removeElement($retained)) { // set the owning side to null (unless already changed) if ($retained->getSchool() === $this) { $retained->setSchool(null); } } return $this; } public function getCity(): ?string { return $this->city; } public function setCity(?string $city): static { $this->city = $city; return $this; } public function getPhone1(): ?string { return $this->phone1; } public function setPhone1(?string $phone1): static { $this->phone1 = $phone1; return $this; } public function getPhone2(): ?string { return $this->phone2; } public function setPhone2(?string $phone2): static { $this->phone2 = $phone2; return $this; } public function getBox(): ?string { return $this->box; } public function setBox(?string $box): static { $this->box = $box; return $this; } /** * @return Collection<int, HonnorTableLimitMoy> */ public function getHonnorTableLimitMoys(): Collection { return $this->honnorTableLimitMoys; } public function addHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static { if (!$this->honnorTableLimitMoys->contains($honnorTableLimitMoy)) { $this->honnorTableLimitMoys->add($honnorTableLimitMoy); $honnorTableLimitMoy->setSchool($this); } return $this; } public function removeHonnorTableLimitMoy(HonnorTableLimitMoy $honnorTableLimitMoy): static { if ($this->honnorTableLimitMoys->removeElement($honnorTableLimitMoy)) { // set the owning side to null (unless already changed) if ($honnorTableLimitMoy->getSchool() === $this) { $honnorTableLimitMoy->setSchool(null); } } return $this; } /** * @return Collection<int, SchoolYearInfos> */ public function getSchoolYearInfos(): Collection { return $this->schoolYearInfos; } public function addSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static { if (!$this->schoolYearInfos->contains($schoolYearInfo)) { $this->schoolYearInfos->add($schoolYearInfo); $schoolYearInfo->setSchool($this); } return $this; } public function removeSchoolYearInfo(SchoolYearInfos $schoolYearInfo): static { if ($this->schoolYearInfos->removeElement($schoolYearInfo)) { // set the owning side to null (unless already changed) if ($schoolYearInfo->getSchool() === $this) { $schoolYearInfo->setSchool(null); } } return $this; } /** * @return Collection<int, AdmissionLimit> */ public function getAdmissionLimits(): Collection { return $this->admissionLimits; } public function addAdmissionLimit(AdmissionLimit $admissionLimit): static { if (!$this->admissionLimits->contains($admissionLimit)) { $this->admissionLimits->add($admissionLimit); $admissionLimit->setSchool($this); } return $this; } public function removeAdmissionLimit(AdmissionLimit $admissionLimit): static { if ($this->admissionLimits->removeElement($admissionLimit)) { // set the owning side to null (unless already changed) if ($admissionLimit->getSchool() === $this) { $admissionLimit->setSchool(null); } } return $this; } public function getAgendaTimeConvertion(): ?AgendaTimeConvertion { return $this->agendaTimeConvertion; } public function setAgendaTimeConvertion(AgendaTimeConvertion $agendaTimeConvertion): static { // set the owning side of the relation if necessary if ($agendaTimeConvertion->getSchool() !== $this) { $agendaTimeConvertion->setSchool($this); } $this->agendaTimeConvertion = $agendaTimeConvertion; return $this; } /** * @return Collection<int, Competence> */ public function getCompetences(): Collection { return $this->competences; } public function addCompetence(Competence $competence): static { if (!$this->competences->contains($competence)) { $this->competences->add($competence); $competence->setSchool($this); } return $this; } public function removeCompetence(Competence $competence): static { if ($this->competences->removeElement($competence)) { // set the owning side to null (unless already changed) if ($competence->getSchool() === $this) { $competence->setSchool(null); } } return $this; } /** * @return Collection<int, WeekSubjectGoal> */ public function getWeekSubjectGoals(): Collection { return $this->weekSubjectGoals; } public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static { if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) { $this->weekSubjectGoals->add($weekSubjectGoal); $weekSubjectGoal->setSchool($this); } return $this; } public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static { if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) { // set the owning side to null (unless already changed) if ($weekSubjectGoal->getSchool() === $this) { $weekSubjectGoal->setSchool(null); } } return $this; } /** * @return Collection<int, ProfSchoolPlanner> */ public function getProfSchoolPlanners(): Collection { return $this->profSchoolPlanners; } public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static { if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) { $this->profSchoolPlanners->add($profSchoolPlanner); $profSchoolPlanner->setSchool($this); } return $this; } public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static { if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) { // set the owning side to null (unless already changed) if ($profSchoolPlanner->getSchool() === $this) { $profSchoolPlanner->setSchool(null); } } return $this; } /** * @return Collection<int, ProfTime> */ public function getProfTimes(): Collection { return $this->profTimes; } public function addProfTime(ProfTime $profTime): static { if (!$this->profTimes->contains($profTime)) { $this->profTimes->add($profTime); $profTime->setSchool($this); } return $this; } public function removeProfTime(ProfTime $profTime): static { if ($this->profTimes->removeElement($profTime)) { // set the owning side to null (unless already changed) if ($profTime->getSchool() === $this) { $profTime->setSchool(null); } } return $this; } /** * @return Collection<int, SchoolPlannerType> */ public function getSchoolPlannerTypes(): Collection { return $this->schoolPlannerTypes; } public function addSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static { if (!$this->schoolPlannerTypes->contains($schoolPlannerType)) { $this->schoolPlannerTypes->add($schoolPlannerType); $schoolPlannerType->setSchool($this); } return $this; } public function removeSchoolPlannerType(SchoolPlannerType $schoolPlannerType): static { if ($this->schoolPlannerTypes->removeElement($schoolPlannerType)) { // set the owning side to null (unless already changed) if ($schoolPlannerType->getSchool() === $this) { $schoolPlannerType->setSchool(null); } } return $this; } /** * @return Collection<int, AgendaElement> */ public function getAgendaElements(): Collection { return $this->agendaElements; } public function addAgendaElement(AgendaElement $agendaElement): static { if (!$this->agendaElements->contains($agendaElement)) { $this->agendaElements->add($agendaElement); $agendaElement->setSchool($this); } return $this; } public function removeAgendaElement(AgendaElement $agendaElement): static { if ($this->agendaElements->removeElement($agendaElement)) { // set the owning side to null (unless already changed) if ($agendaElement->getSchool() === $this) { $agendaElement->setSchool(null); } } return $this; } public function getLogo(): ?string { return $this->logo; } public function setLogo(?string $logo): static { $this->logo = $logo; return $this; } /** * @return Collection<int, GlobalSchoolBreak> */ public function getGlobalSchoolBreaks(): Collection { return $this->globalSchoolBreaks; } public function addGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static { if (!$this->globalSchoolBreaks->contains($globalSchoolBreak)) { $this->globalSchoolBreaks->add($globalSchoolBreak); $globalSchoolBreak->setSchool($this); } return $this; } public function removeGlobalSchoolBreak(GlobalSchoolBreak $globalSchoolBreak): static { if ($this->globalSchoolBreaks->removeElement($globalSchoolBreak)) { // set the owning side to null (unless already changed) if ($globalSchoolBreak->getSchool() === $this) { $globalSchoolBreak->setSchool(null); } } return $this; } /** * @return Collection<int, TeacherAbsence> */ public function getTeacherAbsences(): Collection { return $this->teacherAbsences; } public function addTeacherAbsence(TeacherAbsence $teacherAbsence): static { if (!$this->teacherAbsences->contains($teacherAbsence)) { $this->teacherAbsences->add($teacherAbsence); $teacherAbsence->setSchool($this); } return $this; } public function removeTeacherAbsence(TeacherAbsence $teacherAbsence): static { if ($this->teacherAbsences->removeElement($teacherAbsence)) { // set the owning side to null (unless already changed) if ($teacherAbsence->getSchool() === $this) { $teacherAbsence->setSchool(null); } } return $this; } /** * @return Collection<int, AttendanceMissed> */ public function getAttendanceMisseds(): Collection { return $this->attendanceMisseds; } public function addAttendanceMissed(AttendanceMissed $attendanceMissed): static { if (!$this->attendanceMisseds->contains($attendanceMissed)) { $this->attendanceMisseds->add($attendanceMissed); $attendanceMissed->setSchool($this); } return $this; } public function removeAttendanceMissed(AttendanceMissed $attendanceMissed): static { if ($this->attendanceMisseds->removeElement($attendanceMissed)) { // set the owning side to null (unless already changed) if ($attendanceMissed->getSchool() === $this) { $attendanceMissed->setSchool(null); } } return $this; } /** * @return Collection<int, GeneralBreak> */ public function getGeneralBreaks(): Collection { return $this->generalBreaks; } public function addGeneralBreak(GeneralBreak $generalBreak): static { if (!$this->generalBreaks->contains($generalBreak)) { $this->generalBreaks->add($generalBreak); $generalBreak->setSchool($this); } return $this; } public function removeGeneralBreak(GeneralBreak $generalBreak): static { if ($this->generalBreaks->removeElement($generalBreak)) { // set the owning side to null (unless already changed) if ($generalBreak->getSchool() === $this) { $generalBreak->setSchool(null); } } return $this; } public function getRegion(): ?Region { return $this->region; } public function setRegion(?Region $region): static { $this->region = $region; return $this; } public function getDepartment(): ?Department { return $this->department; } public function setDepartment(?Department $department): static { $this->department = $department; return $this; }}