src/Entity/TheClass.php line 15

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. class TheClass
  16. {
  17.     use Timestampable;
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     #[Groups(['homework','note','getStudents','getSubject','getClass','getDiscussionClass','getExamStudent','getStatsStudentParentIndex'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['homework','getLate','note','getStudents','getClass','getDiscussionClass','getDiscussion','getExamStudent','getAbsence','getPunish','getStatsStudentParentIndex'])]
  26.     private ?string $name = null;
  28.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  29.     #[ORM\JoinColumn(nullable: false)]
  30.     private ?SchoolSection $section = null;
  32.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: StudentYear::class)]
  33.     private Collection $studentsYears;
  35.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Subject::class)]
  36.     private Collection $subjects;
  38.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: HomeWork::class)]
  39.     private Collection $homeWorks;
  41.     #[ORM\Column(nullable: true)]
  42.     private ?bool $active = null;
  44.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Note::class)]
  45.     private Collection $notes;
  47.     #[ORM\ManyToMany(targetEntity: UserYear::class, mappedBy: 'classes')]
  48.     private Collection $userYears;
  50.     #[ORM\ManyToMany(targetEntity: DocInfo::class, mappedBy: 'classes', cascade: ['persist', 'remove'])]
  51.     private Collection $docInfos;
  53.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  54.     private ?User $author = null;
  56.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClassesEdited')]
  57.     private ?User $editor = null;
  60.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  61.     #[Groups(['getClass'])]
  62.     private ?School $school = null;
  64.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DiscussionClass::class)]
  65.     private Collection $discussionClasses;
  67.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubjectGroup::class, orphanRemoval: true)]
  68.     private Collection $subjectGroups;
  70.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Scolarity::class, orphanRemoval: true)]
  71.     private Collection $scolarities;
  73.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ExamAgenda::class)]
  74.     private Collection $examAgendas;
  76.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubSequence::class, orphanRemoval: true)]
  77.     private Collection $subSequences;
  79.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Quarter::class, orphanRemoval: true)]
  80.     private Collection $quarters;
  82.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubNote::class, orphanRemoval: true)]
  83.     private Collection $subNotes;
  86.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Punish::class)]
  87.     private Collection $punishes;
  89.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineWarning::class)]
  90.     private Collection $disciplineWarnings;
  92.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineBlame::class)]
  93.     private Collection $disciplineBlames;
  95.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineExclusion::class)]
  96.     private Collection $disciplineExclusions;
  98.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ParentNote::class)]
  99.     private Collection $parentNotes;
  101.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Absence::class)]
  102.     private Collection $absences;
  104.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineRetained::class)]
  105.     private Collection $disciplineRetaineds;
  107.     #[ORM\ManyToOne(inversedBy: 'theClassesTeached')]
  108.     private ?User $prof = null;
  110.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryParentNote::class)]
  111.     private Collection $primaryParentNotes;
  113.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryNote::class)]
  114.     private Collection $primaryNotes;
  116.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplinePunish::class)]
  117.     private Collection $disciplinePunishes;
  119.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Late::class)]
  120.     private Collection $lates;
  122.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Blame::class)]
  123.     private Collection $blames;
  125.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Warning::class)]
  126.     private Collection $warnings;
  128.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Retained::class)]
  129.     private Collection $retaineds;
  131.     #[ORM\Column(length: 255, nullable: true)]
  132.     private ?string $slug = null;
  134.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineConcile::class)]
  135.     private Collection $disciplineConciles;
  137.     #[ORM\ManyToOne(inversedBy: 'principalClasses')]
  138.     private ?UserYear $principalProf = null;
  140.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Competence::class)]
  141.     private Collection $competences;
  143.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: WeekSubjectGoal::class)]
  144.     private Collection $weekSubjectGoals;
  146.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: AgendaElement::class)]
  147.     private Collection $agendaElements;
  149.     #[ORM\ManyToOne(inversedBy: 'classes')]
  150.     private ?ClassLevel $classLevel = null;
  152.     #[ORM\ManyToMany(targetEntity: ClassOption::class, inversedBy: 'theClasses')]
  153.     #[ORM\JoinTable(name: 'the_class_class_option')]
  154.     private Collection $classOptions;
  156.     #[ORM\ManyToMany(targetEntity: TheClass::class)]
  157.     #[ORM\JoinTable(
  158.         name: 'class_next_class',
  159.         joinColumns: [new ORM\JoinColumn(name: 'class_id', referencedColumnName: 'id')],
  160.         inverseJoinColumns: [new ORM\JoinColumn(name: 'next_class_id', referencedColumnName: 'id')]
  161.     )]
  162.     private Collection $nextClasses;
  164.     public function __toString(): string
  165.     {
  166.         return $this->name;
  167.     }
  169.     public function __construct()
  170.     {
  171.         $this->subjects = new ArrayCollection();
  172.         $this->studentsYears = new ArrayCollection();
  173.         $this->homeWorks = new ArrayCollection();
  174.         $this->notes = new ArrayCollection();
  175.         $this->userYears = new ArrayCollection();
  176.         $this->docInfos = new ArrayCollection();
  177.         $this->discussionClasses = new ArrayCollection();
  178.         $this->subjectGroups = new ArrayCollection();
  179.         $this->scolarities = new ArrayCollection();
  180.         $this->subSequences = new ArrayCollection();
  181.         $this->quarters = new ArrayCollection();
  182.         $this->subNotes = new ArrayCollection();
  183.         $this->disciplineWarnings = new ArrayCollection();
  184.         $this->disciplineBlames = new ArrayCollection();
  185.         $this->disciplineExclusions = new ArrayCollection();
  186.         $this->parentNotes = new ArrayCollection();
  187.         $this->absences = new ArrayCollection();
  188.         $this->disciplineRetaineds = new ArrayCollection();
  189.         $this->primaryParentNotes = new ArrayCollection();
  190.         $this->primaryNotes = new ArrayCollection();
  191.         $this->punishes = new ArrayCollection();
  192.         $this->disciplinePunishes = new ArrayCollection();
  193.         $this->lates = new ArrayCollection();
  194.         $this->blames = new ArrayCollection();
  195.         $this->warnings = new ArrayCollection();
  196.         $this->retaineds = new ArrayCollection();
  197.         $this->disciplineConciles = new ArrayCollection();
  198.         $this->competences = new ArrayCollection();
  199.         $this->weekSubjectGoals = new ArrayCollection();
  200.         $this->agendaElements = new ArrayCollection();
  201.         $this->classOptions   = new ArrayCollection();
  202.         $this->nextClasses    = new ArrayCollection();
  203.     }
  205.     public function getId(): ?int
  206.     {
  207.         return $this->id;
  208.     }
  210.     public function getName(): ?string
  211.     {
  212.         return $this->name;
  213.     }
  215.     public function setName(string $name): static
  216.     {
  217.         $this->name = $name;
  219.         return $this;
  220.     }
  222.     public function getSection(): ?SchoolSection
  223.     {
  224.         return $this->section;
  225.     }
  227.     public function setSection(?SchoolSection $section): static
  228.     {
  229.         $this->section = $section;
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, StudentYear>
  236.      */
  237.     public function getStudentsYears(): Collection
  238.     {
  239.         return $this->studentsYears;
  240.     }
  242.     public function addStudentsYear(StudentYear $studentsYear): static
  243.     {
  244.         if (!$this->studentsYears->contains($studentsYear)) {
  245.             $this->studentsYears->add($studentsYear);
  246.             $studentsYear->setClasse($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeStudentsYear(StudentYear $studentsYear): static
  253.     {
  254.         if ($this->studentsYears->removeElement($studentsYear)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($studentsYear->getClasse() === $this) {
  257.                 $studentsYear->setClasse(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @return Collection<int, Subject>
  266.      */
  267.     public function getSubjects(): Collection
  268.     {
  269.         return $this->subjects;
  270.     }
  272.     public function addSubject(Subject $subject): static
  273.     {
  274.         if (!$this->subjects->contains($subject)) {
  275.             $this->subjects->add($subject);
  276.             $subject->setClasse($this);
  277.         }
  279.         return $this;
  280.     }
  282.     public function removeSubject(Subject $subject): static
  283.     {
  284.         if ($this->subjects->removeElement($subject)) {
  285.             // set the owning side to null (unless already changed)
  286.             if ($subject->getClasse() === $this) {
  287.                 $subject->setClasse(null);
  288.             }
  289.         }
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection<int, HomeWork>
  296.      */
  297.     public function getHomeWorks(): Collection
  298.     {
  299.         return $this->homeWorks;
  300.     }
  302.     public function addHomeWork(HomeWork $homeWork): static
  303.     {
  304.         if (!$this->homeWorks->contains($homeWork)) {
  305.             $this->homeWorks->add($homeWork);
  306.             $homeWork->setClasse($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeHomework(HomeWork $homeWork): static
  313.     {
  314.         if ($this->homeWorks->removeElement($homeWork)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($homeWork->getClasse() === $this) {
  317.                 $homeWork->setClasse(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     public function isActive(): ?bool
  325.     {
  326.         return $this->active;
  327.     }
  329.     public function setActive(?bool $active): static
  330.     {
  331.         $this->active = $active;
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection<int, Note>
  338.      */
  339.     public function getNotes(): Collection
  340.     {
  341.         return $this->notes;
  342.     }
  344.     public function addNote(Note $note): static
  345.     {
  346.         if (!$this->notes->contains($note)) {
  347.             $this->notes->add($note);
  348.             $note->setClasse($this);
  349.         }
  351.         return $this;
  352.     }
  354.     public function removeNote(Note $note): static
  355.     {
  356.         if ($this->notes->removeElement($note)) {
  357.             // set the owning side to null (unless already changed)
  358.             if ($note->getClasse() === $this) {
  359.                 $note->setClasse(null);
  360.             }
  361.         }
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection<int, UserYear>
  368.      */
  369.     public function getUserYears(): Collection
  370.     {
  371.         return $this->userYears;
  372.     }
  374.     public function addUserYear(UserYear $userYear): static
  375.     {
  376.         if (!$this->userYears->contains($userYear)) {
  377.             $this->userYears->add($userYear);
  378.             $userYear->addClass($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeUserYear(UserYear $userYear): static
  385.     {
  386.         if ($this->userYears->removeElement($userYear)) {
  387.             $userYear->removeClass($this);
  388.         }
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, DocInfo>
  395.      */
  396.     public function getDocInfos(): Collection
  397.     {
  398.         return $this->docInfos;
  399.     }
  401.     public function addDocInfo(DocInfo $docInfo): static
  402.     {
  403.         if (!$this->docInfos->contains($docInfo)) {
  404.             $this->docInfos->add($docInfo);
  405.             $docInfo->addClass($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeDocInfo(DocInfo $docInfo): static
  412.     {
  413.         if ($this->docInfos->removeElement($docInfo)) {
  414.             $docInfo->removeClass($this);
  415.         }
  417.         return $this;
  418.     }
  420.     public function getAuthor(): ?User
  421.     {
  422.         return $this->author;
  423.     }
  425.     public function setAuthor(?User $author): static
  426.     {
  427.         $this->author = $author;
  429.         return $this;
  430.     }
  432.     public function getEditor(): ?User
  433.     {
  434.         return $this->editor;
  435.     }
  437.     public function setEditor(?User $editor): static
  438.     {
  439.         $this->editor = $editor;
  441.         return $this;
  442.     }
  444.     public function getSchool(): ?School
  445.     {
  446.         return $this->school;
  447.     }
  449.     public function setSchool(?School $school): static
  450.     {
  451.         $this->school = $school;
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection<int, DiscussionClass>
  458.      */
  459.     public function getDiscussionClasses(): Collection
  460.     {
  461.         return $this->discussionClasses;
  462.     }
  464.     public function addDiscussionClass(DiscussionClass $discussionClass): static
  465.     {
  466.         if (!$this->discussionClasses->contains($discussionClass)) {
  467.             $this->discussionClasses->add($discussionClass);
  468.             $discussionClass->setClasse($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
  475.     {
  476.         if ($this->discussionClasses->removeElement($discussionClass)) {
  477.             // set the owning side to null (unless already changed)
  478.             if ($discussionClass->getClasse() === $this) {
  479.                 $discussionClass->setClasse(null);
  480.             }
  481.         }
  483.         return $this;
  484.     }
  486.     /**
  487.      * @return Collection<int, SubjectGroup>
  488.      */
  489.     public function getSubjectGroups(): Collection
  490.     {
  491.         return $this->subjectGroups;
  492.     }
  494.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  495.     {
  496.         if (!$this->subjectGroups->contains($subjectGroup)) {
  497.             $this->subjectGroups->add($subjectGroup);
  498.             $subjectGroup->setClasse($this);
  499.         }
  501.         return $this;
  502.     }
  504.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  505.     {
  506.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  507.             // set the owning side to null (unless already changed)
  508.             if ($subjectGroup->getClasse() === $this) {
  509.                 $subjectGroup->setClasse(null);
  510.             }
  511.         }
  513.         return $this;
  514.     }
  516.     /**
  517.      * @return Collection<int, Scolarity>
  518.      */
  519.     public function getScolarities(): Collection
  520.     {
  521.         return $this->scolarities;
  522.     }
  524.     public function addScolarity(Scolarity $scolarity): static
  525.     {
  526.         if (!$this->scolarities->contains($scolarity)) {
  527.             $this->scolarities->add($scolarity);
  528.             $scolarity->setClasse($this);
  529.         }
  531.         return $this;
  532.     }
  534.     public function removeScolarity(Scolarity $scolarity): static
  535.     {
  536.         if ($this->scolarities->removeElement($scolarity)) {
  537.             // set the owning side to null (unless already changed)
  538.             if ($scolarity->getClasse() === $this) {
  539.                 $scolarity->setClasse(null);
  540.             }
  541.         }
  543.         return $this;
  544.     }
  546.     /**
  547.      * @return Collection<int, ExamAgenda>
  548.      */
  549.     public function getExamAgendas(): Collection
  550.     {
  551.         return $this->examAgendas;
  552.     }
  554.     public function addExamAgenda(ExamAgenda $examAgenda): static
  555.     {
  556.         if (!$this->examAgendas->contains($examAgenda)) {
  557.             $this->examAgendas->add($examAgenda);
  558.             $examAgenda->setClasse($this);
  559.         }
  561.         return $this;
  562.     }
  564.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  565.     {
  566.         if ($this->examAgendas->removeElement($examAgenda)) {
  567.             // set the owning side to null (unless already changed)
  568.             if ($examAgenda->getClasse() === $this) {
  569.                 $examAgenda->setClasse(null);
  570.             }
  571.         }
  573.         return $this;
  574.     }
  576.     /**
  577.      * @return Collection<int, SubSequence>
  578.      */
  579.     public function getSubSequences(): Collection
  580.     {
  581.         return $this->subSequences;
  582.     }
  584.     public function addSubSequence(SubSequence $subSequence): static
  585.     {
  586.         if (!$this->subSequences->contains($subSequence)) {
  587.             $this->subSequences->add($subSequence);
  588.             $subSequence->setClasse($this);
  589.         }
  591.         return $this;
  592.     }
  594.     public function removeSubSequence(SubSequence $subSequence): static
  595.     {
  596.         if ($this->subSequences->removeElement($subSequence)) {
  597.             // set the owning side to null (unless already changed)
  598.             if ($subSequence->getClasse() === $this) {
  599.                 $subSequence->setClasse(null);
  600.             }
  601.         }
  603.         return $this;
  604.     }
  606.     /**
  607.      * @return Collection<int, Quarter>
  608.      */
  609.     public function getQuarters(): Collection
  610.     {
  611.         return $this->quarters;
  612.     }
  614.     public function addQuarter(Quarter $quarter): static
  615.     {
  616.         if (!$this->quarters->contains($quarter)) {
  617.             $this->quarters->add($quarter);
  618.             $quarter->setClasse($this);
  619.         }
  621.         return $this;
  622.     }
  624.     public function removeQuarter(Quarter $quarter): static
  625.     {
  626.         if ($this->quarters->removeElement($quarter)) {
  627.             // set the owning side to null (unless already changed)
  628.             if ($quarter->getClasse() === $this) {
  629.                 $quarter->setClasse(null);
  630.             }
  631.         }
  633.         return $this;
  634.     }
  636.     /**
  637.      * @return Collection<int, SubNote>
  638.      */
  639.     public function getSubNotes(): Collection
  640.     {
  641.         return $this->subNotes;
  642.     }
  644.     public function addSubNote(SubNote $subNote): static
  645.     {
  646.         if (!$this->subNotes->contains($subNote)) {
  647.             $this->subNotes->add($subNote);
  648.             $subNote->setClasse($this);
  649.         }
  651.         return $this;
  652.     }
  654.     public function removeSubNote(SubNote $subNote): static
  655.     {
  656.         if ($this->subNotes->removeElement($subNote)) {
  657.             // set the owning side to null (unless already changed)
  658.             if ($subNote->getClasse() === $this) {
  659.                 $subNote->setClasse(null);
  660.             }
  661.         }
  663.         return $this;
  664.     }
  666.     /**
  667.      * @return Collection<int, Punish>
  668.      */
  669.     public function getPunishes(): Collection
  670.     {
  671.         return $this->punishes;
  672.     }
  674.     public function addPunish(Punish $punish): static
  675.     {
  676.         if (!$this->punishes->contains($punish)) {
  677.             $this->punishes->add($punish);
  678.             $punish->setClass($this);
  679.         }
  680.         return $this;
  681.     }
  683.     /**
  684.      * @return Collection<int, DisciplineWarning>
  685.      */
  686.     public function getDisciplineWarnings(): Collection
  687.     {
  688.         return $this->disciplineWarnings;
  689.     }
  691.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  692.     {
  693.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  694.             $this->disciplineWarnings->add($disciplineWarning);
  695.             $disciplineWarning->setClasse($this);
  696.         }
  698.         return $this;
  699.     }
  701.     public function removePunish(Punish $punish): static
  702.     {
  703.         if ($this->punishes->removeElement($punish)) {
  704.             // set the owning side to null (unless already changed)
  705.             if ($punish->getClass() === $this) {
  706.                 $punish->setClass(null);
  707.             }
  708.             return $this;
  709.         }
  710.     }
  711.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  712.     {
  713.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  714.             // set the owning side to null (unless already changed)
  715.             if ($disciplineWarning->getClasse() === $this) {
  716.                 $disciplineWarning->setClasse(null);
  717.             }
  718.         }
  720.         return $this;
  721.     }
  723.     /**
  724.      * @return Collection<int, DisciplineBlame>
  725.      */
  726.     public function getDisciplineBlames(): Collection
  727.     {
  728.         return $this->disciplineBlames;
  729.     }
  731.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  732.     {
  733.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  734.             $this->disciplineBlames->add($disciplineBlame);
  735.             $disciplineBlame->setClasse($this);
  736.         }
  738.         return $this;
  739.     }
  741.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  742.     {
  743.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  744.             // set the owning side to null (unless already changed)
  745.             if ($disciplineBlame->getClasse() === $this) {
  746.                 $disciplineBlame->setClasse(null);
  747.             }
  748.         }
  750.         return $this;
  751.     }
  753.     /**
  754.      * @return Collection<int, DisciplineExclusion>
  755.      */
  756.     public function getDisciplineExclusions(): Collection
  757.     {
  758.         return $this->disciplineExclusions;
  759.     }
  761.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  762.     {
  763.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  764.             $this->disciplineExclusions->add($disciplineExclusion);
  765.             $disciplineExclusion->setClasse($this);
  766.         }
  768.         return $this;
  769.     }
  771.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  772.     {
  773.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  774.             // set the owning side to null (unless already changed)
  775.             if ($disciplineExclusion->getClasse() === $this) {
  776.                 $disciplineExclusion->setClasse(null);
  777.             }
  778.         }
  780.         return $this;
  781.     }
  783.     /**
  784.      * @return Collection<int, ParentNote>
  785.      */
  786.     public function getParentNotes(): Collection
  787.     {
  788.         return $this->parentNotes;
  789.     }
  791.     public function addParentNote(ParentNote $parentNote): static
  792.     {
  793.         if (!$this->parentNotes->contains($parentNote)) {
  794.             $this->parentNotes->add($parentNote);
  795.             $parentNote->setClasse($this);
  796.         }
  798.         return $this;
  799.     }
  801.     public function removeParentNote(ParentNote $parentNote): static
  802.     {
  803.         if ($this->parentNotes->removeElement($parentNote)) {
  804.             // set the owning side to null (unless already changed)
  805.             if ($parentNote->getClasse() === $this) {
  806.                 $parentNote->setClasse(null);
  807.             }
  808.         }
  810.         return $this;
  811.     }
  813.     /**
  814.      * @return Collection<int, Absence>
  815.      */
  816.     public function getAbsences(): Collection
  817.     {
  818.         return $this->absences;
  819.     }
  821.     public function addAbsence(Absence $absence): static
  822.     {
  823.         if (!$this->absences->contains($absence)) {
  824.             $this->absences->add($absence);
  825.             $absence->setClasse($this);
  826.         }
  828.         return $this;
  829.     }
  831.     public function removeAbsence(Absence $absence): static
  832.     {
  833.         if ($this->absences->removeElement($absence)) {
  834.             // set the owning side to null (unless already changed)
  835.             if ($absence->getClasse() === $this) {
  836.                 $absence->setClasse(null);
  837.             }
  838.         }
  840.         return $this;
  841.     }
  843.     /**
  844.      * @return Collection<int, DisciplineRetained>
  845.      */
  846.     public function getDisciplineRetaineds(): Collection
  847.     {
  848.         return $this->disciplineRetaineds;
  849.     }
  851.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  852.     {
  853.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  854.             $this->disciplineRetaineds->add($disciplineRetained);
  855.             $disciplineRetained->setClasse($this);
  856.         }
  858.         return $this;
  859.     }
  861.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  862.     {
  863.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  864.             // set the owning side to null (unless already changed)
  865.             if ($disciplineRetained->getClasse() === $this) {
  866.                 $disciplineRetained->setClasse(null);
  867.             }
  868.         }
  870.         return $this;
  871.     }
  873.     public function getProf(): ?User
  874.     {
  875.         return $this->prof;
  876.     }
  878.     public function setProf(?User $prof): static
  879.     {
  880.         $this->prof = $prof;
  882.         return $this;
  883.     }
  885.     /**
  886.      * @return Collection<int, PrimaryParentNote>
  887.      */
  888.     public function getPrimaryParentNotes(): Collection
  889.     {
  890.         return $this->primaryParentNotes;
  891.     }
  893.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  894.     {
  895.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
  896.             $this->primaryParentNotes->add($primaryParentNote);
  897.             $primaryParentNote->setClasse($this);
  898.         }
  900.         return $this;
  901.     }
  903.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  904.     {
  905.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
  906.             // set the owning side to null (unless already changed)
  907.             if ($primaryParentNote->getClasse() === $this) {
  908.                 $primaryParentNote->setClasse(null);
  909.             }
  910.         }
  912.         return $this;
  913.     }
  915.     /**
  916.      * @return Collection<int, PrimaryNote>
  917.      */
  918.     public function getPrimaryNotes(): Collection
  919.     {
  920.         return $this->primaryNotes;
  921.     }
  923.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  924.     {
  925.         if (!$this->primaryNotes->contains($primaryNote)) {
  926.             $this->primaryNotes->add($primaryNote);
  927.             $primaryNote->setClasse($this);
  928.         }
  930.         return $this;
  931.     }
  933.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  934.     {
  935.         if ($this->primaryNotes->removeElement($primaryNote)) {
  936.             // set the owning side to null (unless already changed)
  937.             if ($primaryNote->getClasse() === $this) {
  938.                 $primaryNote->setClasse(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  945.     /**
  946.      * @return Collection<int, DisciplinePunish>
  947.      */
  948.     public function getDisciplinePunishes(): Collection
  949.     {
  950.         return $this->disciplinePunishes;
  951.     }
  953.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  954.     {
  955.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  956.             $this->disciplinePunishes->add($disciplinePunish);
  957.             $disciplinePunish->setClasse($this);
  958.         }
  960.         return $this;
  961.     }
  963.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  964.     {
  965.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  966.             // set the owning side to null (unless already changed)
  967.             if ($disciplinePunish->getClasse() === $this) {
  968.                 $disciplinePunish->setClasse(null);
  969.             }
  970.         }
  972.         return $this;
  973.     }
  975.     /**
  976.      * @return Collection<int, Late>
  977.      */
  978.     public function getLates(): Collection
  979.     {
  980.         return $this->lates;
  981.     }
  983.     public function addLate(Late $late): static
  984.     {
  985.         if (!$this->lates->contains($late)) {
  986.             $this->lates->add($late);
  987.             $late->setClasse($this);
  988.         }
  990.         return $this;
  991.     }
  993.     public function removeLate(Late $late): static
  994.     {
  995.         if ($this->lates->removeElement($late)) {
  996.             // set the owning side to null (unless already changed)
  997.             if ($late->getClasse() === $this) {
  998.                 $late->setClasse(null);
  999.             }
  1000.         }
  1002.         return $this;
  1003.     }
  1005.     /**
  1006.      * @return Collection<int, Blame>
  1007.      */
  1008.     public function getBlames(): Collection
  1009.     {
  1010.         return $this->blames;
  1011.     }
  1013.     public function addBlame(Blame $blame): static
  1014.     {
  1015.         if (!$this->blames->contains($blame)) {
  1016.             $this->blames->add($blame);
  1017.             $blame->setClasse($this);
  1018.         }
  1020.         return $this;
  1021.     }
  1023.     public function removeBlame(Blame $blame): static
  1024.     {
  1025.         if ($this->blames->removeElement($blame)) {
  1026.             // set the owning side to null (unless already changed)
  1027.             if ($blame->getClasse() === $this) {
  1028.                 $blame->setClasse(null);
  1029.             }
  1030.         }
  1032.         return $this;
  1033.     }
  1035.     /**
  1036.      * @return Collection<int, Warning>
  1037.      */
  1038.     public function getWarnings(): Collection
  1039.     {
  1040.         return $this->warnings;
  1041.     }
  1043.     public function addWarning(Warning $warning): static
  1044.     {
  1045.         if (!$this->warnings->contains($warning)) {
  1046.             $this->warnings->add($warning);
  1047.             $warning->setClasse($this);
  1048.         }
  1050.         return $this;
  1051.     }
  1053.     public function removeWarning(Warning $warning): static
  1054.     {
  1055.         if ($this->warnings->removeElement($warning)) {
  1056.             // set the owning side to null (unless already changed)
  1057.             if ($warning->getClasse() === $this) {
  1058.                 $warning->setClasse(null);
  1059.             }
  1060.         }
  1062.         return $this;
  1063.     }
  1065.     /**
  1066.      * @return Collection<int, Retained>
  1067.      */
  1068.     public function getRetaineds(): Collection
  1069.     {
  1070.         return $this->retaineds;
  1071.     }
  1073.     public function addRetained(Retained $retained): static
  1074.     {
  1075.         if (!$this->retaineds->contains($retained)) {
  1076.             $this->retaineds->add($retained);
  1077.             $retained->setClasse($this);
  1078.         }
  1080.         return $this;
  1081.     }
  1083.     public function removeRetained(Retained $retained): static
  1084.     {
  1085.         if ($this->retaineds->removeElement($retained)) {
  1086.             // set the owning side to null (unless already changed)
  1087.             if ($retained->getClasse() === $this) {
  1088.                 $retained->setClasse(null);
  1089.             }
  1090.         }
  1092.         return $this;
  1093.     }
  1095.     public function getSlug(): ?string
  1096.     {
  1097.         return $this->slug;
  1098.     }
  1100.     public function setSlug(?string $slug): static
  1101.     {
  1102.         $this->slug = $slug;
  1104.         return $this;
  1105.     }
  1107.     /**
  1108.      * @return Collection<int, DisciplineConcile>
  1109.      */
  1110.     public function getDisciplineConciles(): Collection
  1111.     {
  1112.         return $this->disciplineConciles;
  1113.     }
  1115.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1116.     {
  1117.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  1118.             $this->disciplineConciles->add($disciplineConcile);
  1119.             $disciplineConcile->setClasse($this);
  1120.         }
  1122.         return $this;
  1123.     }
  1125.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1126.     {
  1127.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  1128.             // set the owning side to null (unless already changed)
  1129.             if ($disciplineConcile->getClasse() === $this) {
  1130.                 $disciplineConcile->setClasse(null);
  1131.             }
  1132.         }
  1134.         return $this;
  1135.     }
  1137.     public function getPrincipalProf(): ?UserYear
  1138.     {
  1139.         return $this->principalProf;
  1140.     }
  1142.     public function setPrincipalProf(?UserYear $principalProf): static
  1143.     {
  1144.         $this->principalProf = $principalProf;
  1146.         return $this;
  1147.     }
  1149.     /**
  1150.      * @return Collection<int, Competence>
  1151.      */
  1152.     public function getCompetences(): Collection
  1153.     {
  1154.         return $this->competences;
  1155.     }
  1157.     public function addCompetence(Competence $competence): static
  1158.     {
  1159.         if (!$this->competences->contains($competence)) {
  1160.             $this->competences->add($competence);
  1161.             $competence->setClasse($this);
  1162.         }
  1164.         return $this;
  1165.     }
  1167.     public function removeCompetence(Competence $competence): static
  1168.     {
  1169.         if ($this->competences->removeElement($competence)) {
  1170.             // set the owning side to null (unless already changed)
  1171.             if ($competence->getClasse() === $this) {
  1172.                 $competence->setClasse(null);
  1173.             }
  1174.         }
  1176.         return $this;
  1177.     }
  1179.     /**
  1180.      * @return Collection<int, WeekSubjectGoal>
  1181.      */
  1182.     public function getWeekSubjectGoals(): Collection
  1183.     {
  1184.         return $this->weekSubjectGoals;
  1185.     }
  1187.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1188.     {
  1189.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  1190.             $this->weekSubjectGoals->add($weekSubjectGoal);
  1191.             $weekSubjectGoal->setClasse($this);
  1192.         }
  1194.         return $this;
  1195.     }
  1197.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1198.     {
  1199.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  1200.             // set the owning side to null (unless already changed)
  1201.             if ($weekSubjectGoal->getClasse() === $this) {
  1202.                 $weekSubjectGoal->setClasse(null);
  1203.             }
  1204.         }
  1206.         return $this;
  1207.     }
  1209.     /**
  1210.      * @return Collection<int, AgendaElement>
  1211.      */
  1212.     public function getAgendaElements(): Collection
  1213.     {
  1214.         return $this->agendaElements;
  1215.     }
  1217.     public function addAgendaElement(AgendaElement $agendaElement): static
  1218.     {
  1219.         if (!$this->agendaElements->contains($agendaElement)) {
  1220.             $this->agendaElements->add($agendaElement);
  1221.             $agendaElement->setClasse($this);
  1222.         }
  1224.         return $this;
  1225.     }
  1227.     public function removeAgendaElement(AgendaElement $agendaElement): static
  1228.     {
  1229.         if ($this->agendaElements->removeElement($agendaElement)) {
  1230.             // set the owning side to null (unless already changed)
  1231.             if ($agendaElement->getClasse() === $this) {
  1232.                 $agendaElement->setClasse(null);
  1233.             }
  1234.         }
  1236.         return $this;
  1237.     }
  1239.     public function getClassLevel(): ?ClassLevel
  1240.     {
  1241.         return $this->classLevel;
  1242.     }
  1244.     public function setClassLevel(?ClassLevel $classLevel): static
  1245.     {
  1246.         $this->classLevel = $classLevel;
  1248.         return $this;
  1249.     }
  1251.     // ── ClassOptions (ManyToMany) ──────────────────────────────────────
  1253.     /**
  1254.      * @return Collection<int, ClassOption>
  1255.      */
  1256.     public function getClassOptions(): Collection
  1257.     {
  1258.         return $this->classOptions;
  1259.     }
  1261.     public function addClassOption(ClassOption $classOption): static
  1262.     {
  1263.         if (!$this->classOptions->contains($classOption)) {
  1264.             $this->classOptions->add($classOption);
  1265.             $classOption->addTheClass($this);
  1266.         }
  1267.         return $this;
  1268.     }
  1270.     public function removeClassOption(ClassOption $classOption): static
  1271.     {
  1272.         if ($this->classOptions->removeElement($classOption)) {
  1273.             $classOption->removeTheClass($this);
  1274.         }
  1275.         return $this;
  1276.     }
  1278.     /**
  1279.      * Compatibilité : retourne la première option si elle existe.
  1280.      * Utile pour les vues qui n'affichent qu'une option.
  1281.      */
  1282.     public function getClassOption(): ?ClassOption
  1283.     {
  1284.         return $this->classOptions->first() ?: null;
  1285.     }
  1287.     // ── NextClasses (promotion) ─────────────────────────────────────────
  1289.     /**
  1290.      * @return Collection<int, TheClass>
  1291.      */
  1292.     public function getNextClasses(): Collection
  1293.     {
  1294.         return $this->nextClasses;
  1295.     }
  1297.     public function addNextClass(TheClass $nextClass): static
  1298.     {
  1299.         if (!$this->nextClasses->contains($nextClass)) {
  1300.             $this->nextClasses->add($nextClass);
  1301.         }
  1302.         return $this;
  1303.     }
  1305.     public function removeNextClass(TheClass $nextClass): static
  1306.     {
  1307.         $this->nextClasses->removeElement($nextClass);
  1308.         return $this;
  1309.     }
  1311.     /**
  1312.      * Retourne true si cette classe a exactement 1 classe suivante
  1313.      * (promotion automatique possible).
  1314.      */
  1315.     public function hasSingleNextClass(): bool
  1316.     {
  1317.         return $this->nextClasses->count() === 1;
  1318.     }
  1319. }