Symfony Profiler

<?php
namespace 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;
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
#[Groups(['getStudents','getSubject','getAppUsers','getClass'])]
private ?int $id = null;
#[ORM\Column(length: 255)]
#[Groups(['getStudents'])]
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 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;
}
}

src/Entity/School.php line 14