src/Entity/TheClass.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\TheClassRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use JMS\Serializer\Annotation\Groups;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use App\Entity\Traits\Timestampable;
  13. #[ORM\HasLifecycleCallbacks]
  14. #[ORM\Entity(repositoryClass: TheClassRepository::class)]
  15. #[UniqueEntity(fields: ['name'], message: 'There is already an class with this name')]
  16. class TheClass
  17. {
  18.     use Timestampable;
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column]
  22.     #[Groups(['homework','note','getStudents','getSubject','getClass','getDiscussionClass','getExamStudent'])]
  23.     private ?int $id = null;
  25.     #[ORM\Column(length: 255)]
  26.     #[Groups(['homework','note','getStudents','getClass','getDiscussionClass','getDiscussion','getExamStudent'])]
  27.     private ?string $name = null;
  29.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  30.     #[ORM\JoinColumn(nullable: false)]
  31.     private ?SchoolSection $section = null;
  33.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: StudentYear::class)]
  34.     private Collection $studentsYears;
  36.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Subject::class)]
  37.     private Collection $subjects;
  39.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: HomeWork::class)]
  40.     private Collection $homeworks;
  42.     #[ORM\Column(nullable: true)]
  43.     private ?bool $active = null;
  45.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Note::class)]
  46.     private Collection $notes;
  48.     #[ORM\ManyToMany(targetEntity: UserYear::class, mappedBy: 'classes')]
  49.     private Collection $userYears;
  51.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Exams::class)]
  52.     private Collection $exams;
  54.     #[ORM\ManyToMany(targetEntity: DocInfo::class, mappedBy: 'classes' , cascade: ['persist', 'remove'], orphanRemoval: true)]
  55.     private Collection $docInfos;
  57.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  58.     private ?User $author = null;
  60.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClassesEdited')]
  61.     private ?User $editor = null;
  64.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  65.     #[Groups(['getClass'])]
  66.     private ?School $school = null;
  68.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DiscussionClass::class)]
  69.     private Collection $discussionClasses;
  71.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Agenda::class)]
  72.     private Collection $agendas;
  74.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubjectGroup::class, orphanRemoval: true)]
  75.     private Collection $subjectGroups;
  77.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Scolarity::class, orphanRemoval: true)]
  78.     private Collection $scolarities;
  80.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ExamAgenda::class)]
  81.     private Collection $examAgendas;
  83.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubSequence::class, orphanRemoval: true)]
  84.     private Collection $subSequences;
  86.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Quarter::class, orphanRemoval: true)]
  87.     private Collection $quarters;
  89.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubNote::class, orphanRemoval: true)]
  90.     private Collection $subNotes;
  93.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Punish::class)]
  94.     private Collection $punishes;
  96.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineWarning::class)]
  97.     private Collection $disciplineWarnings;
  99.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineBlame::class)]
  100.     private Collection $disciplineBlames;
  102.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineExclusion::class)]
  103.     private Collection $disciplineExclusions;
  105.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ParentNote::class)]
  106.     private Collection $parentNotes;
  108.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Absence::class)]
  109.     private Collection $absences;
  111.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineRetained::class)]
  112.     private Collection $disciplineRetaineds;
  114.     #[ORM\ManyToOne(inversedBy: 'theClassesTeached')]
  115.     private ?User $prof = null;
  117.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryParentNote::class)]
  118.     private Collection $primaryParentNotes;
  120.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryNote::class)]
  121.     private Collection $primaryNotes;
  123.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplinePunish::class)]
  124.     private Collection $disciplinePunishes;
  126.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Late::class)]
  127.     private Collection $lates;
  129.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Blame::class)]
  130.     private Collection $blames;
  132.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Warning::class)]
  133.     private Collection $warnings;
  135.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Retained::class)]
  136.     private Collection $retaineds;
  138.     #[ORM\Column(length: 255, nullable: true)]
  139.     private ?string $slug = null;
  141.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineConcile::class)]
  142.     private Collection $disciplineConciles;
  144.     #[ORM\ManyToOne(inversedBy: 'pricipalClasses')]
  145.     private ?UserYear $principalProf = null;
  147.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: StudentPreInscription::class)]
  148.     private Collection $studentPreInscriptions;
  150.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: TimeTableClass::class)]
  151.     private Collection $timeTableClasses;
  153.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: TimeTable::class)]
  154.     private Collection $timeTables;
  156.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: TimeTable::class)]
  157.     private Collection $TimeTableClasse;
  159.     public function __toString(): string
  160.     {
  161.         return $this->name;
  162.     }
  164.     public function __construct()
  165.     {
  166.         $this->subjects = new ArrayCollection();
  167.         $this->studentYears = new ArrayCollection();
  168.         $this->homeWorks = new ArrayCollection();
  169.         $this->notes = new ArrayCollection();
  170.         $this->userYears = new ArrayCollection();
  171.         $this->exams = new ArrayCollection();
  172.         $this->docInfos = new ArrayCollection();
  173.         $this->discussionClasses = new ArrayCollection();
  174.         $this->agendas = new ArrayCollection();
  175.         $this->subjectGroups = new ArrayCollection();
  176.         $this->scolarities = new ArrayCollection();
  177.         $this->subSequences = new ArrayCollection();
  178.         $this->quarters = new ArrayCollection();
  179.         $this->subNotes = new ArrayCollection();
  180.         $this->disciplineWarnings = new ArrayCollection();
  181.         $this->disciplineBlames = new ArrayCollection();
  182.         $this->disciplineExclusions = new ArrayCollection();
  183.         $this->parentNotes = new ArrayCollection();
  184.         $this->absences = new ArrayCollection();
  185.         $this->disciplineRetaineds = new ArrayCollection();
  186.         $this->primaryParentNotes = new ArrayCollection();
  187.         $this->primaryNotes = new ArrayCollection();
  188.         $this->punishes = new ArrayCollection();
  189.         $this->disciplinePunishes = new ArrayCollection();
  190.         $this->lates = new ArrayCollection();
  191.         $this->blames = new ArrayCollection();
  192.         $this->warnings = new ArrayCollection();
  193.         $this->retaineds = new ArrayCollection();
  194.         $this->disciplineConciles = new ArrayCollection();
  195.         $this->studentPreInscriptions = new ArrayCollection();
  196.         $this->timeTableClasses = new ArrayCollection();
  197.         $this->timeTables = new ArrayCollection();
  198.         $this->TimeTableClasse = new ArrayCollection();
  199.     }
  201.     public function getId(): ?int
  202.     {
  203.         return $this->id;
  204.     }
  206.     public function getName(): ?string
  207.     {
  208.         return $this->name;
  209.     }
  211.     public function setName(string $name): static
  212.     {
  213.         $this->name = $name;
  215.         return $this;
  216.     }
  218.     public function getSection(): ?SchoolSection
  219.     {
  220.         return $this->section;
  221.     }
  223.     public function setSection(?SchoolSection $section): static
  224.     {
  225.         $this->section = $section;
  227.         return $this;
  228.     }
  230.     /**
  231.      * @return Collection<int, StudentYear>
  232.      */
  233.     public function getStudentsYears(): Collection
  234.     {
  235.         return $this->studentsYears;
  236.     }
  238.     public function addStudentsYear(StudentYear $studentsYear): static
  239.     {
  240.         if (!$this->studentsYears->contains($studentsYear)) {
  241.             $this->studentsYears->add($studentsYear);
  242.             $studentsYear->setClasse($this);
  243.         }
  245.         return $this;
  246.     }
  248.     public function removeStudentsYear(StudentYear $studentsYear): static
  249.     {
  250.         if ($this->studentsYears->removeElement($studentsYear)) {
  251.             // set the owning side to null (unless already changed)
  252.             if ($studentsYear->getClasse() === $this) {
  253.                 $studentsYear->setClasse(null);
  254.             }
  255.         }
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return Collection<int, Subject>
  262.      */
  263.     public function getSubjects(): Collection
  264.     {
  265.         return $this->subjects;
  266.     }
  268.     public function addSubject(Subject $subject): static
  269.     {
  270.         if (!$this->subjects->contains($subject)) {
  271.             $this->subjects->add($subject);
  272.             $subject->setClasse($this);
  273.         }
  275.         return $this;
  276.     }
  278.     public function removeSubject(Subject $subject): static
  279.     {
  280.         if ($this->subjects->removeElement($subject)) {
  281.             // set the owning side to null (unless already changed)
  282.             if ($subject->getClasse() === $this) {
  283.                 $subject->setClasse(null);
  284.             }
  285.         }
  287.         return $this;
  288.     }
  290.     /**
  291.      * @return Collection<int, HomeWork>
  292.      */
  293.     public function getHomeworks(): Collection
  294.     {
  295.         return $this->homeworks;
  296.     }
  298.     public function addHomework(HomeWork $homework): static
  299.     {
  300.         if (!$this->homeworks->contains($homework)) {
  301.             $this->homeworks->add($homework);
  302.             $homework->setClasse($this);
  303.         }
  305.         return $this;
  306.     }
  308.     public function removeHomework(HomeWork $homework): static
  309.     {
  310.         if ($this->homeworks->removeElement($homework)) {
  311.             // set the owning side to null (unless already changed)
  312.             if ($homework->getClasse() === $this) {
  313.                 $homework->setClasse(null);
  314.             }
  315.         }
  317.         return $this;
  318.     }
  320.     public function isActive(): ?bool
  321.     {
  322.         return $this->active;
  323.     }
  325.     public function setActive(?bool $active): static
  326.     {
  327.         $this->active = $active;
  329.         return $this;
  330.     }
  332.     /**
  333.      * @return Collection<int, Note>
  334.      */
  335.     public function getNotes(): Collection
  336.     {
  337.         return $this->notes;
  338.     }
  340.     public function addNote(Note $note): static
  341.     {
  342.         if (!$this->notes->contains($note)) {
  343.             $this->notes->add($note);
  344.             $note->setClasse($this);
  345.         }
  347.         return $this;
  348.     }
  350.     public function removeNote(Note $note): static
  351.     {
  352.         if ($this->notes->removeElement($note)) {
  353.             // set the owning side to null (unless already changed)
  354.             if ($note->getClasse() === $this) {
  355.                 $note->setClasse(null);
  356.             }
  357.         }
  359.         return $this;
  360.     }
  362.     /**
  363.      * @return Collection<int, UserYear>
  364.      */
  365.     public function getUserYears(): Collection
  366.     {
  367.         return $this->userYears;
  368.     }
  370.     public function addUserYear(UserYear $userYear): static
  371.     {
  372.         if (!$this->userYears->contains($userYear)) {
  373.             $this->userYears->add($userYear);
  374.             $userYear->addClass($this);
  375.         }
  377.         return $this;
  378.     }
  380.     public function removeUserYear(UserYear $userYear): static
  381.     {
  382.         if ($this->userYears->removeElement($userYear)) {
  383.             $userYear->removeClass($this);
  384.         }
  386.         return $this;
  387.     }
  389.     /**
  390.      * @return Collection<int, Exams>
  391.      */
  392.     public function getExams(): Collection
  393.     {
  394.         return $this->exams;
  395.     }
  397.     public function addExam(Exams $exam): static
  398.     {
  399.         if (!$this->exams->contains($exam)) {
  400.             $this->exams->add($exam);
  401.             $exam->setClasse($this);
  402.         }
  404.         return $this;
  405.     }
  407.     public function removeExam(Exams $exam): static
  408.     {
  409.         if ($this->exams->removeElement($exam)) {
  410.             // set the owning side to null (unless already changed)
  411.             if ($exam->getClasse() === $this) {
  412.                 $exam->setClasse(null);
  413.             }
  414.         }
  416.         return $this;
  417.     }
  419.     /**
  420.      * @return Collection<int, DocInfo>
  421.      */
  422.     public function getDocInfos(): Collection
  423.     {
  424.         return $this->docInfos;
  425.     }
  427.     public function addDocInfo(DocInfo $docInfo): static
  428.     {
  429.         if (!$this->docInfos->contains($docInfo)) {
  430.             $this->docInfos->add($docInfo);
  431.             $docInfo->addClass($this);
  432.         }
  434.         return $this;
  435.     }
  437.     public function removeDocInfo(DocInfo $docInfo): static
  438.     {
  439.         if ($this->docInfos->removeElement($docInfo)) {
  440.             $docInfo->removeClass($this);
  441.         }
  443.         return $this;
  444.     }
  446.     public function getAuthor(): ?User
  447.     {
  448.         return $this->author;
  449.     }
  451.     public function setAuthor(?User $author): static
  452.     {
  453.         $this->author = $author;
  455.         return $this;
  456.     }
  458.     public function getEditor(): ?User
  459.     {
  460.         return $this->editor;
  461.     }
  463.     public function setEditor(?User $editor): static
  464.     {
  465.         $this->editor = $editor;
  467.         return $this;
  468.     }
  470.     public function getSchool(): ?School
  471.     {
  472.         return $this->school;
  473.     }
  475.     public function setSchool(?School $school): static
  476.     {
  477.         $this->school = $school;
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, DiscussionClass>
  484.      */
  485.     public function getDiscussionClasses(): Collection
  486.     {
  487.         return $this->discussionClasses;
  488.     }
  490.     public function addDiscussionClass(DiscussionClass $discussionClass): static
  491.     {
  492.         if (!$this->discussionClasses->contains($discussionClass)) {
  493.             $this->discussionClasses->add($discussionClass);
  494.             $discussionClass->setClasse($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
  501.     {
  502.         if ($this->discussionClasses->removeElement($discussionClass)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($discussionClass->getClasse() === $this) {
  505.                 $discussionClass->setClasse(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, Agenda>
  514.      */
  515.     public function getAgendas(): Collection
  516.     {
  517.         return $this->agendas;
  518.     }
  520.     public function addAgenda(Agenda $agenda): static
  521.     {
  522.         if (!$this->agendas->contains($agenda)) {
  523.             $this->agendas->add($agenda);
  524.             $agenda->setClasse($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeAgenda(Agenda $agenda): static
  531.     {
  532.         if ($this->agendas->removeElement($agenda)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($agenda->getClasse() === $this) {
  535.                 $agenda->setClasse(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     /**
  543.      * @return Collection<int, SubjectGroup>
  544.      */
  545.     public function getSubjectGroups(): Collection
  546.     {
  547.         return $this->subjectGroups;
  548.     }
  550.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  551.     {
  552.         if (!$this->subjectGroups->contains($subjectGroup)) {
  553.             $this->subjectGroups->add($subjectGroup);
  554.             $subjectGroup->setClasse($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  561.     {
  562.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($subjectGroup->getClasse() === $this) {
  565.                 $subjectGroup->setClasse(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  572.     /**
  573.      * @return Collection<int, Scolarity>
  574.      */
  575.     public function getScolarities(): Collection
  576.     {
  577.         return $this->scolarities;
  578.     }
  580.     public function addScolarity(Scolarity $scolarity): static
  581.     {
  582.         if (!$this->scolarities->contains($scolarity)) {
  583.             $this->scolarities->add($scolarity);
  584.             $scolarity->setClasse($this);
  585.         }
  587.         return $this;
  588.     }
  590.     public function removeScolarity(Scolarity $scolarity): static
  591.     {
  592.         if ($this->scolarities->removeElement($scolarity)) {
  593.             // set the owning side to null (unless already changed)
  594.             if ($scolarity->getClasse() === $this) {
  595.                 $scolarity->setClasse(null);
  596.             }
  597.         }
  599.         return $this;
  600.     }
  602.     /**
  603.      * @return Collection<int, ExamAgenda>
  604.      */
  605.     public function getExamAgendas(): Collection
  606.     {
  607.         return $this->examAgendas;
  608.     }
  610.     public function addExamAgenda(ExamAgenda $examAgenda): static
  611.     {
  612.         if (!$this->examAgendas->contains($examAgenda)) {
  613.             $this->examAgendas->add($examAgenda);
  614.             $examAgenda->setClasse($this);
  615.         }
  617.         return $this;
  618.     }
  620.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  621.     {
  622.         if ($this->examAgendas->removeElement($examAgenda)) {
  623.             // set the owning side to null (unless already changed)
  624.             if ($examAgenda->getClasse() === $this) {
  625.                 $examAgenda->setClasse(null);
  626.             }
  627.         }
  629.         return $this;
  630.     }
  632.     /**
  633.      * @return Collection<int, SubSequence>
  634.      */
  635.     public function getSubSequences(): Collection
  636.     {
  637.         return $this->subSequences;
  638.     }
  640.     public function addSubSequence(SubSequence $subSequence): static
  641.     {
  642.         if (!$this->subSequences->contains($subSequence)) {
  643.             $this->subSequences->add($subSequence);
  644.             $subSequence->setClasse($this);
  645.         }
  647.         return $this;
  648.     }
  650.     public function removeSubSequence(SubSequence $subSequence): static
  651.     {
  652.         if ($this->subSequences->removeElement($subSequence)) {
  653.             // set the owning side to null (unless already changed)
  654.             if ($subSequence->getClasse() === $this) {
  655.                 $subSequence->setClasse(null);
  656.             }
  657.         }
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return Collection<int, Quarter>
  664.      */
  665.     public function getQuarters(): Collection
  666.     {
  667.         return $this->quarters;
  668.     }
  670.     public function addQuarter(Quarter $quarter): static
  671.     {
  672.         if (!$this->quarters->contains($quarter)) {
  673.             $this->quarters->add($quarter);
  674.             $quarter->setClasse($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeQuarter(Quarter $quarter): static
  681.     {
  682.         if ($this->quarters->removeElement($quarter)) {
  683.             // set the owning side to null (unless already changed)
  684.             if ($quarter->getClasse() === $this) {
  685.                 $quarter->setClasse(null);
  686.             }
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * @return Collection<int, SubNote>
  694.      */
  695.     public function getSubNotes(): Collection
  696.     {
  697.         return $this->subNotes;
  698.     }
  700.     public function addSubNote(SubNote $subNote): static
  701.     {
  702.         if (!$this->subNotes->contains($subNote)) {
  703.             $this->subNotes->add($subNote);
  704.             $subNote->setClasse($this);
  705.         }
  707.         return $this;
  708.     }
  710.     public function removeSubNote(SubNote $subNote): static
  711.     {
  712.         if ($this->subNotes->removeElement($subNote)) {
  713.             // set the owning side to null (unless already changed)
  714.             if ($subNote->getClasse() === $this) {
  715.                 $subNote->setClasse(null);
  716.             }
  717.         }
  719.         return $this;
  720.     }
  722.     /**
  723.      * @return Collection<int, Punish>
  724.      */
  725.     public function getPunishes(): Collection
  726.     {
  727.         return $this->punishes;
  728.     }
  730.     public function addPunish(Punish $punish): static
  731.     {
  732.         if (!$this->punishes->contains($punish)) {
  733.             $this->punishes->add($punish);
  734.             $punish->setClass($this);
  735.         }
  736.         return $this;
  737.     }
  739.     /**
  740.      * @return Collection<int, DisciplineWarning>
  741.      */
  742.     public function getDisciplineWarnings(): Collection
  743.     {
  744.         return $this->disciplineWarnings;
  745.     }
  747.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  748.     {
  749.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  750.             $this->disciplineWarnings->add($disciplineWarning);
  751.             $disciplineWarning->setClasse($this);
  752.         }
  754.         return $this;
  755.     }
  757.     public function removePunish(Punish $punish): static
  758.     {
  759.         if ($this->punishes->removeElement($punish)) {
  760.             // set the owning side to null (unless already changed)
  761.             if ($punish->getClass() === $this) {
  762.                 $punish->setClass(null);
  763.             }
  764.             return $this;
  765.         }
  766.     }
  767.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  768.     {
  769.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  770.             // set the owning side to null (unless already changed)
  771.             if ($disciplineWarning->getClasse() === $this) {
  772.                 $disciplineWarning->setClasse(null);
  773.             }
  774.         }
  776.         return $this;
  777.     }
  779.     /**
  780.      * @return Collection<int, DisciplineBlame>
  781.      */
  782.     public function getDisciplineBlames(): Collection
  783.     {
  784.         return $this->disciplineBlames;
  785.     }
  787.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  788.     {
  789.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  790.             $this->disciplineBlames->add($disciplineBlame);
  791.             $disciplineBlame->setClasse($this);
  792.         }
  794.         return $this;
  795.     }
  797.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  798.     {
  799.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  800.             // set the owning side to null (unless already changed)
  801.             if ($disciplineBlame->getClasse() === $this) {
  802.                 $disciplineBlame->setClasse(null);
  803.             }
  804.         }
  806.         return $this;
  807.     }
  809.     /**
  810.      * @return Collection<int, DisciplineExclusion>
  811.      */
  812.     public function getDisciplineExclusions(): Collection
  813.     {
  814.         return $this->disciplineExclusions;
  815.     }
  817.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  818.     {
  819.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  820.             $this->disciplineExclusions->add($disciplineExclusion);
  821.             $disciplineExclusion->setClasse($this);
  822.         }
  824.         return $this;
  825.     }
  827.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  828.     {
  829.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  830.             // set the owning side to null (unless already changed)
  831.             if ($disciplineExclusion->getClasse() === $this) {
  832.                 $disciplineExclusion->setClasse(null);
  833.             }
  834.         }
  836.         return $this;
  837.     }
  839.     /**
  840.      * @return Collection<int, ParentNote>
  841.      */
  842.     public function getParentNotes(): Collection
  843.     {
  844.         return $this->parentNotes;
  845.     }
  847.     public function addParentNote(ParentNote $parentNote): static
  848.     {
  849.         if (!$this->parentNotes->contains($parentNote)) {
  850.             $this->parentNotes->add($parentNote);
  851.             $parentNote->setClasse($this);
  852.         }
  854.         return $this;
  855.     }
  857.     public function removeParentNote(ParentNote $parentNote): static
  858.     {
  859.         if ($this->parentNotes->removeElement($parentNote)) {
  860.             // set the owning side to null (unless already changed)
  861.             if ($parentNote->getClasse() === $this) {
  862.                 $parentNote->setClasse(null);
  863.             }
  864.         }
  866.         return $this;
  867.     }
  869.     /**
  870.      * @return Collection<int, Absence>
  871.      */
  872.     public function getAbsences(): Collection
  873.     {
  874.         return $this->absences;
  875.     }
  877.     public function addAbsence(Absence $absence): static
  878.     {
  879.         if (!$this->absences->contains($absence)) {
  880.             $this->absences->add($absence);
  881.             $absence->setClasse($this);
  882.         }
  884.         return $this;
  885.     }
  887.     public function removeAbsence(Absence $absence): static
  888.     {
  889.         if ($this->absences->removeElement($absence)) {
  890.             // set the owning side to null (unless already changed)
  891.             if ($absence->getClasse() === $this) {
  892.                 $absence->setClasse(null);
  893.             }
  894.         }
  896.         return $this;
  897.     }
  899.     /**
  900.      * @return Collection<int, DisciplineRetained>
  901.      */
  902.     public function getDisciplineRetaineds(): Collection
  903.     {
  904.         return $this->disciplineRetaineds;
  905.     }
  907.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  908.     {
  909.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  910.             $this->disciplineRetaineds->add($disciplineRetained);
  911.             $disciplineRetained->setClasse($this);
  912.         }
  914.         return $this;
  915.     }
  917.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  918.     {
  919.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  920.             // set the owning side to null (unless already changed)
  921.             if ($disciplineRetained->getClasse() === $this) {
  922.                 $disciplineRetained->setClasse(null);
  923.             }
  924.         }
  926.         return $this;
  927.     }
  929.     public function getProf(): ?User
  930.     {
  931.         return $this->prof;
  932.     }
  934.     public function setProf(?User $prof): static
  935.     {
  936.         $this->prof = $prof;
  938.         return $this;
  939.     }
  941.     /**
  942.      * @return Collection<int, PrimaryParentNote>
  943.      */
  944.     public function getPrimaryParentNotes(): Collection
  945.     {
  946.         return $this->primaryParentNotes;
  947.     }
  949.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  950.     {
  951.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
  952.             $this->primaryParentNotes->add($primaryParentNote);
  953.             $primaryParentNote->setClasse($this);
  954.         }
  956.         return $this;
  957.     }
  959.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  960.     {
  961.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
  962.             // set the owning side to null (unless already changed)
  963.             if ($primaryParentNote->getClasse() === $this) {
  964.                 $primaryParentNote->setClasse(null);
  965.             }
  966.         }
  968.         return $this;
  969.     }
  971.     /**
  972.      * @return Collection<int, PrimaryNote>
  973.      */
  974.     public function getPrimaryNotes(): Collection
  975.     {
  976.         return $this->primaryNotes;
  977.     }
  979.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  980.     {
  981.         if (!$this->primaryNotes->contains($primaryNote)) {
  982.             $this->primaryNotes->add($primaryNote);
  983.             $primaryNote->setClasse($this);
  984.         }
  986.         return $this;
  987.     }
  989.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  990.     {
  991.         if ($this->primaryNotes->removeElement($primaryNote)) {
  992.             // set the owning side to null (unless already changed)
  993.             if ($primaryNote->getClasse() === $this) {
  994.                 $primaryNote->setClasse(null);
  995.             }
  996.         }
  998.         return $this;
  999.     }
  1001.     /**
  1002.      * @return Collection<int, DisciplinePunish>
  1003.      */
  1004.     public function getDisciplinePunishes(): Collection
  1005.     {
  1006.         return $this->disciplinePunishes;
  1007.     }
  1009.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  1010.     {
  1011.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  1012.             $this->disciplinePunishes->add($disciplinePunish);
  1013.             $disciplinePunish->setClasse($this);
  1014.         }
  1016.         return $this;
  1017.     }
  1019.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  1020.     {
  1021.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  1022.             // set the owning side to null (unless already changed)
  1023.             if ($disciplinePunish->getClasse() === $this) {
  1024.                 $disciplinePunish->setClasse(null);
  1025.             }
  1026.         }
  1028.         return $this;
  1029.     }
  1031.     /**
  1032.      * @return Collection<int, Late>
  1033.      */
  1034.     public function getLates(): Collection
  1035.     {
  1036.         return $this->lates;
  1037.     }
  1039.     public function addLate(Late $late): static
  1040.     {
  1041.         if (!$this->lates->contains($late)) {
  1042.             $this->lates->add($late);
  1043.             $late->setClasse($this);
  1044.         }
  1046.         return $this;
  1047.     }
  1049.     public function removeLate(Late $late): static
  1050.     {
  1051.         if ($this->lates->removeElement($late)) {
  1052.             // set the owning side to null (unless already changed)
  1053.             if ($late->getClasse() === $this) {
  1054.                 $late->setClasse(null);
  1055.             }
  1056.         }
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection<int, Blame>
  1063.      */
  1064.     public function getBlames(): Collection
  1065.     {
  1066.         return $this->blames;
  1067.     }
  1069.     public function addBlame(Blame $blame): static
  1070.     {
  1071.         if (!$this->blames->contains($blame)) {
  1072.             $this->blames->add($blame);
  1073.             $blame->setClasse($this);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     public function removeBlame(Blame $blame): static
  1080.     {
  1081.         if ($this->blames->removeElement($blame)) {
  1082.             // set the owning side to null (unless already changed)
  1083.             if ($blame->getClasse() === $this) {
  1084.                 $blame->setClasse(null);
  1085.             }
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     /**
  1092.      * @return Collection<int, Warning>
  1093.      */
  1094.     public function getWarnings(): Collection
  1095.     {
  1096.         return $this->warnings;
  1097.     }
  1099.     public function addWarning(Warning $warning): static
  1100.     {
  1101.         if (!$this->warnings->contains($warning)) {
  1102.             $this->warnings->add($warning);
  1103.             $warning->setClasse($this);
  1104.         }
  1106.         return $this;
  1107.     }
  1109.     public function removeWarning(Warning $warning): static
  1110.     {
  1111.         if ($this->warnings->removeElement($warning)) {
  1112.             // set the owning side to null (unless already changed)
  1113.             if ($warning->getClasse() === $this) {
  1114.                 $warning->setClasse(null);
  1115.             }
  1116.         }
  1118.         return $this;
  1119.     }
  1121.     /**
  1122.      * @return Collection<int, Retained>
  1123.      */
  1124.     public function getRetaineds(): Collection
  1125.     {
  1126.         return $this->retaineds;
  1127.     }
  1129.     public function addRetained(Retained $retained): static
  1130.     {
  1131.         if (!$this->retaineds->contains($retained)) {
  1132.             $this->retaineds->add($retained);
  1133.             $retained->setClasse($this);
  1134.         }
  1136.         return $this;
  1137.     }
  1139.     public function removeRetained(Retained $retained): static
  1140.     {
  1141.         if ($this->retaineds->removeElement($retained)) {
  1142.             // set the owning side to null (unless already changed)
  1143.             if ($retained->getClasse() === $this) {
  1144.                 $retained->setClasse(null);
  1145.             }
  1146.         }
  1148.         return $this;
  1149.     }
  1151.     public function getSlug(): ?string
  1152.     {
  1153.         return $this->slug;
  1154.     }
  1156.     public function setSlug(?string $slug): static
  1157.     {
  1158.         $this->slug = $slug;
  1160.         return $this;
  1161.     }
  1163.     /**
  1164.      * @return Collection<int, DisciplineConcile>
  1165.      */
  1166.     public function getDisciplineConciles(): Collection
  1167.     {
  1168.         return $this->disciplineConciles;
  1169.     }
  1171.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1172.     {
  1173.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  1174.             $this->disciplineConciles->add($disciplineConcile);
  1175.             $disciplineConcile->setClasse($this);
  1176.         }
  1178.         return $this;
  1179.     }
  1181.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1182.     {
  1183.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  1184.             // set the owning side to null (unless already changed)
  1185.             if ($disciplineConcile->getClasse() === $this) {
  1186.                 $disciplineConcile->setClasse(null);
  1187.             }
  1188.         }
  1190.         return $this;
  1191.     }
  1193.     public function getPrincipalProf(): ?UserYear
  1194.     {
  1195.         return $this->principalProf;
  1196.     }
  1198.     public function setPrincipalProf(?UserYear $principalProf): static
  1199.     {
  1200.         $this->principalProf = $principalProf;
  1202.         return $this;
  1203.     }
  1205.     /**
  1206.      * @return Collection<int, StudentPreInscription>
  1207.      */
  1208.     public function getStudentPreInscriptions(): Collection
  1209.     {
  1210.         return $this->studentPreInscriptions;
  1211.     }
  1213.     public function addStudentPreInscription(StudentPreInscription $studentPreInscription): static
  1214.     {
  1215.         if (!$this->studentPreInscriptions->contains($studentPreInscription)) {
  1216.             $this->studentPreInscriptions->add($studentPreInscription);
  1217.             $studentPreInscription->setClasse($this);
  1218.         }
  1220.         return $this;
  1221.     }
  1223.     public function removeStudentPreInscription(StudentPreInscription $studentPreInscription): static
  1224.     {
  1225.         if ($this->studentPreInscriptions->removeElement($studentPreInscription)) {
  1226.             // set the owning side to null (unless already changed)
  1227.             if ($studentPreInscription->getClasse() === $this) {
  1228.                 $studentPreInscription->setClasse(null);
  1229.             }
  1230.         }
  1232.         return $this;
  1233.     }
  1235.     /**
  1236.      * @return Collection<int, TimeTableClass>
  1237.      */
  1238.     public function getTimeTableClasses(): Collection
  1239.     {
  1240.         return $this->timeTableClasses;
  1241.     }
  1243.     public function addTimeTableClass(TimeTableClass $timeTableClass): static
  1244.     {
  1245.         if (!$this->timeTableClasses->contains($timeTableClass)) {
  1246.             $this->timeTableClasses->add($timeTableClass);
  1247.             $timeTableClass->setClasse($this);
  1248.         }
  1250.         return $this;
  1251.     }
  1253.     public function removeTimeTableClass(TimeTableClass $timeTableClass): static
  1254.     {
  1255.         if ($this->timeTableClasses->removeElement($timeTableClass)) {
  1256.             // set the owning side to null (unless already changed)
  1257.             if ($timeTableClass->getClasse() === $this) {
  1258.                 $timeTableClass->setClasse(null);
  1259.             }
  1260.         }
  1262.         return $this;
  1263.     }
  1265.     /**
  1266.      * @return Collection<int, TimeTable>
  1267.      */
  1268.     public function getTimeTables(): Collection
  1269.     {
  1270.         return $this->timeTables;
  1271.     }
  1273.     public function addTimeTable(TimeTable $timeTable): static
  1274.     {
  1275.         if (!$this->timeTables->contains($timeTable)) {
  1276.             $this->timeTables->add($timeTable);
  1277.             $timeTable->setClasse($this);
  1278.         }
  1280.         return $this;
  1281.     }
  1283.     public function removeTimeTable(TimeTable $timeTable): static
  1284.     {
  1285.         if ($this->timeTables->removeElement($timeTable)) {
  1286.             // set the owning side to null (unless already changed)
  1287.             if ($timeTable->getClasse() === $this) {
  1288.                 $timeTable->setClasse(null);
  1289.             }
  1290.         }
  1292.         return $this;
  1293.     }
  1295.     /**
  1296.      * @return Collection<int, TimeTable>
  1297.      */
  1298.     public function getTimeTableClasse(): Collection
  1299.     {
  1300.         return $this->TimeTableClasse;
  1301.     }
  1303.     public function addTimeTableClasse(TimeTable $timeTableClasse): static
  1304.     {
  1305.         if (!$this->TimeTableClasse->contains($timeTableClasse)) {
  1306.             $this->TimeTableClasse->add($timeTableClasse);
  1307.             $timeTableClasse->setClasse($this);
  1308.         }
  1310.         return $this;
  1311.     }
  1313.     public function removeTimeTableClasse(TimeTable $timeTableClasse): static
  1314.     {
  1315.         if ($this->TimeTableClasse->removeElement($timeTableClasse)) {
  1316.             // set the owning side to null (unless already changed)
  1317.             if ($timeTableClasse->getClasse() === $this) {
  1318.                 $timeTableClasse->setClasse(null);
  1319.             }
  1320.         }
  1322.         return $this;
  1323.     }
  1324. }