src/Entity/TheClass.php line 17

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 JMS\Serializer\Annotation\SerializedName;
  11. use JMS\Serializer\Annotation\VirtualProperty;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  13. use App\Entity\Traits\Timestampable;
  15. #[ORM\HasLifecycleCallbacks]
  16. #[ORM\Entity(repositoryClass: TheClassRepository::class)]
  17. class TheClass
  18. {
  19.     use Timestampable;
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     #[Groups(['homework','getLate','note','getStudents','getSubject','getClass','getDiscussionClass','getExamStudent','getStatsStudentParentIndex','getAbsence','getPunish','getAgenda'])]
  24.     private ?int $id = null;
  26.     #[ORM\Column(length: 255)]
  27.     #[Groups(['homework','getLate','note','getStudents','getClass','getDiscussionClass','getDiscussion','getExamStudent','getAbsence','getPunish','getStatsStudentParentIndex','getAbsence','getAgenda'])]
  28.     private ?string $name = null;
  30.     // Utilisée à la place du nom partout où la classe est simplement listée (menus, listes
  31.     // déroulantes, tableaux...) ; le nom complet reste seul utilisé pour la génération des
  32.     // documents (bulletins...). Optionnelle : si absente, on retombe sur le nom complet
  33.     // (voir getDisplayName()).
  34.     #[ORM\Column(length: 20, nullable: true)]
  35.     #[Groups(['homework','getLate','note','getStudents','getClass','getDiscussionClass','getDiscussion','getExamStudent','getAbsence','getPunish','getStatsStudentParentIndex','getAbsence','getAgenda'])]
  36.     private ?string $abreviation = null;
  38.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  39.     #[ORM\JoinColumn(nullable: false)]
  40.     private ?SchoolSection $section = null;
  42.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: StudentYear::class)]
  43.     private Collection $studentsYears;
  45.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Subject::class)]
  46.     private Collection $subjects;
  48.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: HomeWork::class)]
  49.     private Collection $homeWorks;
  51.     #[ORM\Column(nullable: true)]
  52.     private ?bool $active = null;
  54.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Note::class)]
  55.     private Collection $notes;
  57.     #[ORM\ManyToMany(targetEntity: UserYear::class, mappedBy: 'classes')]
  58.     private Collection $userYears;
  60.     #[ORM\ManyToMany(targetEntity: DocInfo::class, mappedBy: 'classes', cascade: ['persist', 'remove'])]
  61.     private Collection $docInfos;
  63.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  64.     private ?User $author = null;
  66.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClassesEdited')]
  67.     private ?User $editor = null;
  70.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'theClasses')]
  71.     #[Groups(['getClass'])]
  72.     private ?School $school = null;
  74.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DiscussionClass::class)]
  75.     private Collection $discussionClasses;
  77.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubjectGroup::class, orphanRemoval: true)]
  78.     private Collection $subjectGroups;
  80.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Scolarity::class, orphanRemoval: true)]
  81.     private Collection $scolarities;
  83.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ExamAgenda::class)]
  84.     private Collection $examAgendas;
  86.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubSequence::class, orphanRemoval: true)]
  87.     private Collection $subSequences;
  89.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Quarter::class, orphanRemoval: true)]
  90.     private Collection $quarters;
  92.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: SubNote::class, orphanRemoval: true)]
  93.     private Collection $subNotes;
  96.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Punish::class)]
  97.     private Collection $punishes;
  99.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineWarning::class)]
  100.     private Collection $disciplineWarnings;
  102.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineBlame::class)]
  103.     private Collection $disciplineBlames;
  105.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineExclusion::class)]
  106.     private Collection $disciplineExclusions;
  108.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: ParentNote::class)]
  109.     private Collection $parentNotes;
  111.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Absence::class)]
  112.     private Collection $absences;
  114.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineRetained::class)]
  115.     private Collection $disciplineRetaineds;
  117.     #[ORM\ManyToOne(inversedBy: 'theClassesTeached')]
  118.     private ?User $prof = null;
  120.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryParentNote::class)]
  121.     private Collection $primaryParentNotes;
  123.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: PrimaryNote::class)]
  124.     private Collection $primaryNotes;
  126.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplinePunish::class)]
  127.     private Collection $disciplinePunishes;
  129.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Late::class)]
  130.     private Collection $lates;
  132.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Blame::class)]
  133.     private Collection $blames;
  135.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Warning::class)]
  136.     private Collection $warnings;
  138.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Retained::class)]
  139.     private Collection $retaineds;
  141.     #[ORM\Column(length: 255, nullable: true)]
  142.     private ?string $slug = null;
  144.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: DisciplineConcile::class)]
  145.     private Collection $disciplineConciles;
  147.     #[ORM\ManyToOne(inversedBy: 'principalClasses')]
  148.     private ?UserYear $principalProf = null;
  150.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Competence::class)]
  151.     private Collection $competences;
  153.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: WeekSubjectGoal::class)]
  154.     private Collection $weekSubjectGoals;
  156.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: AgendaElement::class)]
  157.     private Collection $agendaElements;
  159.     #[ORM\ManyToOne(inversedBy: 'classes')]
  160.     private ?ClassLevel $classLevel = null;
  162.     #[ORM\ManyToMany(targetEntity: ClassOption::class, inversedBy: 'theClasses')]
  163.     #[ORM\JoinTable(name: 'the_class_class_option')]
  164.     private Collection $classOptions;
  166.     #[ORM\ManyToMany(targetEntity: TheClass::class)]
  167.     #[ORM\JoinTable(
  168.         name: 'class_next_class',
  169.         joinColumns: [new ORM\JoinColumn(name: 'class_id', referencedColumnName: 'id')],
  170.         inverseJoinColumns: [new ORM\JoinColumn(name: 'next_class_id', referencedColumnName: 'id')]
  171.     )]
  172.     private Collection $nextClasses;
  174.     public function __toString(): string
  175.     {
  176.         return $this->name;
  177.     }
  179.     public function __construct()
  180.     {
  181.         $this->subjects = new ArrayCollection();
  182.         $this->studentsYears = new ArrayCollection();
  183.         $this->homeWorks = new ArrayCollection();
  184.         $this->notes = new ArrayCollection();
  185.         $this->userYears = new ArrayCollection();
  186.         $this->docInfos = new ArrayCollection();
  187.         $this->discussionClasses = new ArrayCollection();
  188.         $this->subjectGroups = new ArrayCollection();
  189.         $this->scolarities = new ArrayCollection();
  190.         $this->subSequences = new ArrayCollection();
  191.         $this->quarters = new ArrayCollection();
  192.         $this->subNotes = new ArrayCollection();
  193.         $this->disciplineWarnings = new ArrayCollection();
  194.         $this->disciplineBlames = new ArrayCollection();
  195.         $this->disciplineExclusions = new ArrayCollection();
  196.         $this->parentNotes = new ArrayCollection();
  197.         $this->absences = new ArrayCollection();
  198.         $this->disciplineRetaineds = new ArrayCollection();
  199.         $this->primaryParentNotes = new ArrayCollection();
  200.         $this->primaryNotes = new ArrayCollection();
  201.         $this->punishes = new ArrayCollection();
  202.         $this->disciplinePunishes = new ArrayCollection();
  203.         $this->lates = new ArrayCollection();
  204.         $this->blames = new ArrayCollection();
  205.         $this->warnings = new ArrayCollection();
  206.         $this->retaineds = new ArrayCollection();
  207.         $this->disciplineConciles = new ArrayCollection();
  208.         $this->competences = new ArrayCollection();
  209.         $this->weekSubjectGoals = new ArrayCollection();
  210.         $this->agendaElements = new ArrayCollection();
  211.         $this->classOptions   = new ArrayCollection();
  212.         $this->nextClasses    = new ArrayCollection();
  213.     }
  215.     public function getId(): ?int
  216.     {
  217.         return $this->id;
  218.     }
  220.     public function getName(): ?string
  221.     {
  222.         return $this->name;
  223.     }
  225.     public function setName(string $name): static
  226.     {
  227.         $this->name = $name;
  229.         return $this;
  230.     }
  232.     public function getAbreviation(): ?string
  233.     {
  234.         return $this->abreviation;
  235.     }
  237.     public function setAbreviation(?string $abreviation): static
  238.     {
  239.         $this->abreviation = $abreviation;
  241.         return $this;
  242.     }
  244.     // À utiliser partout où la classe est listée (web : `class.displayName` en Twig) ; la
  245.     // génération des documents doit continuer à utiliser getName() directement.
  246.     #[VirtualProperty]
  247.     #[SerializedName('displayName')]
  248.     #[Groups(['homework','getLate','note','getStudents','getClass','getDiscussionClass','getDiscussion','getExamStudent','getAbsence','getPunish','getStatsStudentParentIndex','getAbsence','getAgenda'])]
  249.     public function getDisplayName(): string
  250.     {
  251.         return $this->abreviation ?: $this->name;
  252.     }
  254.     public function getSection(): ?SchoolSection
  255.     {
  256.         return $this->section;
  257.     }
  259.     public function setSection(?SchoolSection $section): static
  260.     {
  261.         $this->section = $section;
  263.         return $this;
  264.     }
  266.     /**
  267.      * @return Collection<int, StudentYear>
  268.      */
  269.     public function getStudentsYears(): Collection
  270.     {
  271.         return $this->studentsYears;
  272.     }
  274.     public function addStudentsYear(StudentYear $studentsYear): static
  275.     {
  276.         if (!$this->studentsYears->contains($studentsYear)) {
  277.             $this->studentsYears->add($studentsYear);
  278.             $studentsYear->setClasse($this);
  279.         }
  281.         return $this;
  282.     }
  284.     public function removeStudentsYear(StudentYear $studentsYear): static
  285.     {
  286.         if ($this->studentsYears->removeElement($studentsYear)) {
  287.             // set the owning side to null (unless already changed)
  288.             if ($studentsYear->getClasse() === $this) {
  289.                 $studentsYear->setClasse(null);
  290.             }
  291.         }
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return Collection<int, Subject>
  298.      */
  299.     public function getSubjects(): Collection
  300.     {
  301.         return $this->subjects;
  302.     }
  304.     public function addSubject(Subject $subject): static
  305.     {
  306.         if (!$this->subjects->contains($subject)) {
  307.             $this->subjects->add($subject);
  308.             $subject->setClasse($this);
  309.         }
  311.         return $this;
  312.     }
  314.     public function removeSubject(Subject $subject): static
  315.     {
  316.         if ($this->subjects->removeElement($subject)) {
  317.             // set the owning side to null (unless already changed)
  318.             if ($subject->getClasse() === $this) {
  319.                 $subject->setClasse(null);
  320.             }
  321.         }
  323.         return $this;
  324.     }
  326.     /**
  327.      * @return Collection<int, HomeWork>
  328.      */
  329.     public function getHomeWorks(): Collection
  330.     {
  331.         return $this->homeWorks;
  332.     }
  334.     public function addHomeWork(HomeWork $homeWork): static
  335.     {
  336.         if (!$this->homeWorks->contains($homeWork)) {
  337.             $this->homeWorks->add($homeWork);
  338.             $homeWork->setClasse($this);
  339.         }
  341.         return $this;
  342.     }
  344.     public function removeHomework(HomeWork $homeWork): static
  345.     {
  346.         if ($this->homeWorks->removeElement($homeWork)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($homeWork->getClasse() === $this) {
  349.                 $homeWork->setClasse(null);
  350.             }
  351.         }
  353.         return $this;
  354.     }
  356.     public function isActive(): ?bool
  357.     {
  358.         return $this->active;
  359.     }
  361.     public function setActive(?bool $active): static
  362.     {
  363.         $this->active = $active;
  365.         return $this;
  366.     }
  368.     /**
  369.      * @return Collection<int, Note>
  370.      */
  371.     public function getNotes(): Collection
  372.     {
  373.         return $this->notes;
  374.     }
  376.     public function addNote(Note $note): static
  377.     {
  378.         if (!$this->notes->contains($note)) {
  379.             $this->notes->add($note);
  380.             $note->setClasse($this);
  381.         }
  383.         return $this;
  384.     }
  386.     public function removeNote(Note $note): static
  387.     {
  388.         if ($this->notes->removeElement($note)) {
  389.             // set the owning side to null (unless already changed)
  390.             if ($note->getClasse() === $this) {
  391.                 $note->setClasse(null);
  392.             }
  393.         }
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, UserYear>
  400.      */
  401.     public function getUserYears(): Collection
  402.     {
  403.         return $this->userYears;
  404.     }
  406.     public function addUserYear(UserYear $userYear): static
  407.     {
  408.         if (!$this->userYears->contains($userYear)) {
  409.             $this->userYears->add($userYear);
  410.             $userYear->addClass($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeUserYear(UserYear $userYear): static
  417.     {
  418.         if ($this->userYears->removeElement($userYear)) {
  419.             $userYear->removeClass($this);
  420.         }
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, DocInfo>
  427.      */
  428.     public function getDocInfos(): Collection
  429.     {
  430.         return $this->docInfos;
  431.     }
  433.     public function addDocInfo(DocInfo $docInfo): static
  434.     {
  435.         if (!$this->docInfos->contains($docInfo)) {
  436.             $this->docInfos->add($docInfo);
  437.             $docInfo->addClass($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeDocInfo(DocInfo $docInfo): static
  444.     {
  445.         if ($this->docInfos->removeElement($docInfo)) {
  446.             $docInfo->removeClass($this);
  447.         }
  449.         return $this;
  450.     }
  452.     public function getAuthor(): ?User
  453.     {
  454.         return $this->author;
  455.     }
  457.     public function setAuthor(?User $author): static
  458.     {
  459.         $this->author = $author;
  461.         return $this;
  462.     }
  464.     public function getEditor(): ?User
  465.     {
  466.         return $this->editor;
  467.     }
  469.     public function setEditor(?User $editor): static
  470.     {
  471.         $this->editor = $editor;
  473.         return $this;
  474.     }
  476.     public function getSchool(): ?School
  477.     {
  478.         return $this->school;
  479.     }
  481.     public function setSchool(?School $school): static
  482.     {
  483.         $this->school = $school;
  485.         return $this;
  486.     }
  488.     /**
  489.      * @return Collection<int, DiscussionClass>
  490.      */
  491.     public function getDiscussionClasses(): Collection
  492.     {
  493.         return $this->discussionClasses;
  494.     }
  496.     public function addDiscussionClass(DiscussionClass $discussionClass): static
  497.     {
  498.         if (!$this->discussionClasses->contains($discussionClass)) {
  499.             $this->discussionClasses->add($discussionClass);
  500.             $discussionClass->setClasse($this);
  501.         }
  503.         return $this;
  504.     }
  506.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
  507.     {
  508.         if ($this->discussionClasses->removeElement($discussionClass)) {
  509.             // set the owning side to null (unless already changed)
  510.             if ($discussionClass->getClasse() === $this) {
  511.                 $discussionClass->setClasse(null);
  512.             }
  513.         }
  515.         return $this;
  516.     }
  518.     /**
  519.      * @return Collection<int, SubjectGroup>
  520.      */
  521.     public function getSubjectGroups(): Collection
  522.     {
  523.         return $this->subjectGroups;
  524.     }
  526.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  527.     {
  528.         if (!$this->subjectGroups->contains($subjectGroup)) {
  529.             $this->subjectGroups->add($subjectGroup);
  530.             $subjectGroup->setClasse($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  537.     {
  538.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  539.             // set the owning side to null (unless already changed)
  540.             if ($subjectGroup->getClasse() === $this) {
  541.                 $subjectGroup->setClasse(null);
  542.             }
  543.         }
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection<int, Scolarity>
  550.      */
  551.     public function getScolarities(): Collection
  552.     {
  553.         return $this->scolarities;
  554.     }
  556.     public function addScolarity(Scolarity $scolarity): static
  557.     {
  558.         if (!$this->scolarities->contains($scolarity)) {
  559.             $this->scolarities->add($scolarity);
  560.             $scolarity->setClasse($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeScolarity(Scolarity $scolarity): static
  567.     {
  568.         if ($this->scolarities->removeElement($scolarity)) {
  569.             // set the owning side to null (unless already changed)
  570.             if ($scolarity->getClasse() === $this) {
  571.                 $scolarity->setClasse(null);
  572.             }
  573.         }
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection<int, ExamAgenda>
  580.      */
  581.     public function getExamAgendas(): Collection
  582.     {
  583.         return $this->examAgendas;
  584.     }
  586.     public function addExamAgenda(ExamAgenda $examAgenda): static
  587.     {
  588.         if (!$this->examAgendas->contains($examAgenda)) {
  589.             $this->examAgendas->add($examAgenda);
  590.             $examAgenda->setClasse($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  597.     {
  598.         if ($this->examAgendas->removeElement($examAgenda)) {
  599.             // set the owning side to null (unless already changed)
  600.             if ($examAgenda->getClasse() === $this) {
  601.                 $examAgenda->setClasse(null);
  602.             }
  603.         }
  605.         return $this;
  606.     }
  608.     /**
  609.      * @return Collection<int, SubSequence>
  610.      */
  611.     public function getSubSequences(): Collection
  612.     {
  613.         return $this->subSequences;
  614.     }
  616.     public function addSubSequence(SubSequence $subSequence): static
  617.     {
  618.         if (!$this->subSequences->contains($subSequence)) {
  619.             $this->subSequences->add($subSequence);
  620.             $subSequence->setClasse($this);
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeSubSequence(SubSequence $subSequence): static
  627.     {
  628.         if ($this->subSequences->removeElement($subSequence)) {
  629.             // set the owning side to null (unless already changed)
  630.             if ($subSequence->getClasse() === $this) {
  631.                 $subSequence->setClasse(null);
  632.             }
  633.         }
  635.         return $this;
  636.     }
  638.     /**
  639.      * @return Collection<int, Quarter>
  640.      */
  641.     public function getQuarters(): Collection
  642.     {
  643.         return $this->quarters;
  644.     }
  646.     public function addQuarter(Quarter $quarter): static
  647.     {
  648.         if (!$this->quarters->contains($quarter)) {
  649.             $this->quarters->add($quarter);
  650.             $quarter->setClasse($this);
  651.         }
  653.         return $this;
  654.     }
  656.     public function removeQuarter(Quarter $quarter): static
  657.     {
  658.         if ($this->quarters->removeElement($quarter)) {
  659.             // set the owning side to null (unless already changed)
  660.             if ($quarter->getClasse() === $this) {
  661.                 $quarter->setClasse(null);
  662.             }
  663.         }
  665.         return $this;
  666.     }
  668.     /**
  669.      * @return Collection<int, SubNote>
  670.      */
  671.     public function getSubNotes(): Collection
  672.     {
  673.         return $this->subNotes;
  674.     }
  676.     public function addSubNote(SubNote $subNote): static
  677.     {
  678.         if (!$this->subNotes->contains($subNote)) {
  679.             $this->subNotes->add($subNote);
  680.             $subNote->setClasse($this);
  681.         }
  683.         return $this;
  684.     }
  686.     public function removeSubNote(SubNote $subNote): static
  687.     {
  688.         if ($this->subNotes->removeElement($subNote)) {
  689.             // set the owning side to null (unless already changed)
  690.             if ($subNote->getClasse() === $this) {
  691.                 $subNote->setClasse(null);
  692.             }
  693.         }
  695.         return $this;
  696.     }
  698.     /**
  699.      * @return Collection<int, Punish>
  700.      */
  701.     public function getPunishes(): Collection
  702.     {
  703.         return $this->punishes;
  704.     }
  706.     public function addPunish(Punish $punish): static
  707.     {
  708.         if (!$this->punishes->contains($punish)) {
  709.             $this->punishes->add($punish);
  710.             $punish->setClass($this);
  711.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, DisciplineWarning>
  717.      */
  718.     public function getDisciplineWarnings(): Collection
  719.     {
  720.         return $this->disciplineWarnings;
  721.     }
  723.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  724.     {
  725.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  726.             $this->disciplineWarnings->add($disciplineWarning);
  727.             $disciplineWarning->setClasse($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removePunish(Punish $punish): static
  734.     {
  735.         if ($this->punishes->removeElement($punish)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($punish->getClass() === $this) {
  738.                 $punish->setClass(null);
  739.             }
  740.             return $this;
  741.         }
  742.     }
  743.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  744.     {
  745.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  746.             // set the owning side to null (unless already changed)
  747.             if ($disciplineWarning->getClasse() === $this) {
  748.                 $disciplineWarning->setClasse(null);
  749.             }
  750.         }
  752.         return $this;
  753.     }
  755.     /**
  756.      * @return Collection<int, DisciplineBlame>
  757.      */
  758.     public function getDisciplineBlames(): Collection
  759.     {
  760.         return $this->disciplineBlames;
  761.     }
  763.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  764.     {
  765.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  766.             $this->disciplineBlames->add($disciplineBlame);
  767.             $disciplineBlame->setClasse($this);
  768.         }
  770.         return $this;
  771.     }
  773.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  774.     {
  775.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  776.             // set the owning side to null (unless already changed)
  777.             if ($disciplineBlame->getClasse() === $this) {
  778.                 $disciplineBlame->setClasse(null);
  779.             }
  780.         }
  782.         return $this;
  783.     }
  785.     /**
  786.      * @return Collection<int, DisciplineExclusion>
  787.      */
  788.     public function getDisciplineExclusions(): Collection
  789.     {
  790.         return $this->disciplineExclusions;
  791.     }
  793.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  794.     {
  795.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  796.             $this->disciplineExclusions->add($disciplineExclusion);
  797.             $disciplineExclusion->setClasse($this);
  798.         }
  800.         return $this;
  801.     }
  803.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  804.     {
  805.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  806.             // set the owning side to null (unless already changed)
  807.             if ($disciplineExclusion->getClasse() === $this) {
  808.                 $disciplineExclusion->setClasse(null);
  809.             }
  810.         }
  812.         return $this;
  813.     }
  815.     /**
  816.      * @return Collection<int, ParentNote>
  817.      */
  818.     public function getParentNotes(): Collection
  819.     {
  820.         return $this->parentNotes;
  821.     }
  823.     public function addParentNote(ParentNote $parentNote): static
  824.     {
  825.         if (!$this->parentNotes->contains($parentNote)) {
  826.             $this->parentNotes->add($parentNote);
  827.             $parentNote->setClasse($this);
  828.         }
  830.         return $this;
  831.     }
  833.     public function removeParentNote(ParentNote $parentNote): static
  834.     {
  835.         if ($this->parentNotes->removeElement($parentNote)) {
  836.             // set the owning side to null (unless already changed)
  837.             if ($parentNote->getClasse() === $this) {
  838.                 $parentNote->setClasse(null);
  839.             }
  840.         }
  842.         return $this;
  843.     }
  845.     /**
  846.      * @return Collection<int, Absence>
  847.      */
  848.     public function getAbsences(): Collection
  849.     {
  850.         return $this->absences;
  851.     }
  853.     public function addAbsence(Absence $absence): static
  854.     {
  855.         if (!$this->absences->contains($absence)) {
  856.             $this->absences->add($absence);
  857.             $absence->setClasse($this);
  858.         }
  860.         return $this;
  861.     }
  863.     public function removeAbsence(Absence $absence): static
  864.     {
  865.         if ($this->absences->removeElement($absence)) {
  866.             // set the owning side to null (unless already changed)
  867.             if ($absence->getClasse() === $this) {
  868.                 $absence->setClasse(null);
  869.             }
  870.         }
  872.         return $this;
  873.     }
  875.     /**
  876.      * @return Collection<int, DisciplineRetained>
  877.      */
  878.     public function getDisciplineRetaineds(): Collection
  879.     {
  880.         return $this->disciplineRetaineds;
  881.     }
  883.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  884.     {
  885.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  886.             $this->disciplineRetaineds->add($disciplineRetained);
  887.             $disciplineRetained->setClasse($this);
  888.         }
  890.         return $this;
  891.     }
  893.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  894.     {
  895.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  896.             // set the owning side to null (unless already changed)
  897.             if ($disciplineRetained->getClasse() === $this) {
  898.                 $disciplineRetained->setClasse(null);
  899.             }
  900.         }
  902.         return $this;
  903.     }
  905.     public function getProf(): ?User
  906.     {
  907.         return $this->prof;
  908.     }
  910.     public function setProf(?User $prof): static
  911.     {
  912.         $this->prof = $prof;
  914.         return $this;
  915.     }
  917.     /**
  918.      * @return Collection<int, PrimaryParentNote>
  919.      */
  920.     public function getPrimaryParentNotes(): Collection
  921.     {
  922.         return $this->primaryParentNotes;
  923.     }
  925.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  926.     {
  927.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
  928.             $this->primaryParentNotes->add($primaryParentNote);
  929.             $primaryParentNote->setClasse($this);
  930.         }
  932.         return $this;
  933.     }
  935.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  936.     {
  937.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
  938.             // set the owning side to null (unless already changed)
  939.             if ($primaryParentNote->getClasse() === $this) {
  940.                 $primaryParentNote->setClasse(null);
  941.             }
  942.         }
  944.         return $this;
  945.     }
  947.     /**
  948.      * @return Collection<int, PrimaryNote>
  949.      */
  950.     public function getPrimaryNotes(): Collection
  951.     {
  952.         return $this->primaryNotes;
  953.     }
  955.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  956.     {
  957.         if (!$this->primaryNotes->contains($primaryNote)) {
  958.             $this->primaryNotes->add($primaryNote);
  959.             $primaryNote->setClasse($this);
  960.         }
  962.         return $this;
  963.     }
  965.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  966.     {
  967.         if ($this->primaryNotes->removeElement($primaryNote)) {
  968.             // set the owning side to null (unless already changed)
  969.             if ($primaryNote->getClasse() === $this) {
  970.                 $primaryNote->setClasse(null);
  971.             }
  972.         }
  974.         return $this;
  975.     }
  977.     /**
  978.      * @return Collection<int, DisciplinePunish>
  979.      */
  980.     public function getDisciplinePunishes(): Collection
  981.     {
  982.         return $this->disciplinePunishes;
  983.     }
  985.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  986.     {
  987.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  988.             $this->disciplinePunishes->add($disciplinePunish);
  989.             $disciplinePunish->setClasse($this);
  990.         }
  992.         return $this;
  993.     }
  995.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  996.     {
  997.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  998.             // set the owning side to null (unless already changed)
  999.             if ($disciplinePunish->getClasse() === $this) {
  1000.                 $disciplinePunish->setClasse(null);
  1001.             }
  1002.         }
  1004.         return $this;
  1005.     }
  1007.     /**
  1008.      * @return Collection<int, Late>
  1009.      */
  1010.     public function getLates(): Collection
  1011.     {
  1012.         return $this->lates;
  1013.     }
  1015.     public function addLate(Late $late): static
  1016.     {
  1017.         if (!$this->lates->contains($late)) {
  1018.             $this->lates->add($late);
  1019.             $late->setClasse($this);
  1020.         }
  1022.         return $this;
  1023.     }
  1025.     public function removeLate(Late $late): static
  1026.     {
  1027.         if ($this->lates->removeElement($late)) {
  1028.             // set the owning side to null (unless already changed)
  1029.             if ($late->getClasse() === $this) {
  1030.                 $late->setClasse(null);
  1031.             }
  1032.         }
  1034.         return $this;
  1035.     }
  1037.     /**
  1038.      * @return Collection<int, Blame>
  1039.      */
  1040.     public function getBlames(): Collection
  1041.     {
  1042.         return $this->blames;
  1043.     }
  1045.     public function addBlame(Blame $blame): static
  1046.     {
  1047.         if (!$this->blames->contains($blame)) {
  1048.             $this->blames->add($blame);
  1049.             $blame->setClasse($this);
  1050.         }
  1052.         return $this;
  1053.     }
  1055.     public function removeBlame(Blame $blame): static
  1056.     {
  1057.         if ($this->blames->removeElement($blame)) {
  1058.             // set the owning side to null (unless already changed)
  1059.             if ($blame->getClasse() === $this) {
  1060.                 $blame->setClasse(null);
  1061.             }
  1062.         }
  1064.         return $this;
  1065.     }
  1067.     /**
  1068.      * @return Collection<int, Warning>
  1069.      */
  1070.     public function getWarnings(): Collection
  1071.     {
  1072.         return $this->warnings;
  1073.     }
  1075.     public function addWarning(Warning $warning): static
  1076.     {
  1077.         if (!$this->warnings->contains($warning)) {
  1078.             $this->warnings->add($warning);
  1079.             $warning->setClasse($this);
  1080.         }
  1082.         return $this;
  1083.     }
  1085.     public function removeWarning(Warning $warning): static
  1086.     {
  1087.         if ($this->warnings->removeElement($warning)) {
  1088.             // set the owning side to null (unless already changed)
  1089.             if ($warning->getClasse() === $this) {
  1090.                 $warning->setClasse(null);
  1091.             }
  1092.         }
  1094.         return $this;
  1095.     }
  1097.     /**
  1098.      * @return Collection<int, Retained>
  1099.      */
  1100.     public function getRetaineds(): Collection
  1101.     {
  1102.         return $this->retaineds;
  1103.     }
  1105.     public function addRetained(Retained $retained): static
  1106.     {
  1107.         if (!$this->retaineds->contains($retained)) {
  1108.             $this->retaineds->add($retained);
  1109.             $retained->setClasse($this);
  1110.         }
  1112.         return $this;
  1113.     }
  1115.     public function removeRetained(Retained $retained): static
  1116.     {
  1117.         if ($this->retaineds->removeElement($retained)) {
  1118.             // set the owning side to null (unless already changed)
  1119.             if ($retained->getClasse() === $this) {
  1120.                 $retained->setClasse(null);
  1121.             }
  1122.         }
  1124.         return $this;
  1125.     }
  1127.     public function getSlug(): ?string
  1128.     {
  1129.         return $this->slug;
  1130.     }
  1132.     public function setSlug(?string $slug): static
  1133.     {
  1134.         $this->slug = $slug;
  1136.         return $this;
  1137.     }
  1139.     /**
  1140.      * @return Collection<int, DisciplineConcile>
  1141.      */
  1142.     public function getDisciplineConciles(): Collection
  1143.     {
  1144.         return $this->disciplineConciles;
  1145.     }
  1147.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1148.     {
  1149.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  1150.             $this->disciplineConciles->add($disciplineConcile);
  1151.             $disciplineConcile->setClasse($this);
  1152.         }
  1154.         return $this;
  1155.     }
  1157.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1158.     {
  1159.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  1160.             // set the owning side to null (unless already changed)
  1161.             if ($disciplineConcile->getClasse() === $this) {
  1162.                 $disciplineConcile->setClasse(null);
  1163.             }
  1164.         }
  1166.         return $this;
  1167.     }
  1169.     public function getPrincipalProf(): ?UserYear
  1170.     {
  1171.         return $this->principalProf;
  1172.     }
  1174.     public function setPrincipalProf(?UserYear $principalProf): static
  1175.     {
  1176.         $this->principalProf = $principalProf;
  1178.         return $this;
  1179.     }
  1181.     /**
  1182.      * @return Collection<int, Competence>
  1183.      */
  1184.     public function getCompetences(): Collection
  1185.     {
  1186.         return $this->competences;
  1187.     }
  1189.     public function addCompetence(Competence $competence): static
  1190.     {
  1191.         if (!$this->competences->contains($competence)) {
  1192.             $this->competences->add($competence);
  1193.             $competence->setClasse($this);
  1194.         }
  1196.         return $this;
  1197.     }
  1199.     public function removeCompetence(Competence $competence): static
  1200.     {
  1201.         if ($this->competences->removeElement($competence)) {
  1202.             // set the owning side to null (unless already changed)
  1203.             if ($competence->getClasse() === $this) {
  1204.                 $competence->setClasse(null);
  1205.             }
  1206.         }
  1208.         return $this;
  1209.     }
  1211.     /**
  1212.      * @return Collection<int, WeekSubjectGoal>
  1213.      */
  1214.     public function getWeekSubjectGoals(): Collection
  1215.     {
  1216.         return $this->weekSubjectGoals;
  1217.     }
  1219.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1220.     {
  1221.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  1222.             $this->weekSubjectGoals->add($weekSubjectGoal);
  1223.             $weekSubjectGoal->setClasse($this);
  1224.         }
  1226.         return $this;
  1227.     }
  1229.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1230.     {
  1231.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  1232.             // set the owning side to null (unless already changed)
  1233.             if ($weekSubjectGoal->getClasse() === $this) {
  1234.                 $weekSubjectGoal->setClasse(null);
  1235.             }
  1236.         }
  1238.         return $this;
  1239.     }
  1241.     /**
  1242.      * @return Collection<int, AgendaElement>
  1243.      */
  1244.     public function getAgendaElements(): Collection
  1245.     {
  1246.         return $this->agendaElements;
  1247.     }
  1249.     public function addAgendaElement(AgendaElement $agendaElement): static
  1250.     {
  1251.         if (!$this->agendaElements->contains($agendaElement)) {
  1252.             $this->agendaElements->add($agendaElement);
  1253.             $agendaElement->setClasse($this);
  1254.         }
  1256.         return $this;
  1257.     }
  1259.     public function removeAgendaElement(AgendaElement $agendaElement): static
  1260.     {
  1261.         if ($this->agendaElements->removeElement($agendaElement)) {
  1262.             // set the owning side to null (unless already changed)
  1263.             if ($agendaElement->getClasse() === $this) {
  1264.                 $agendaElement->setClasse(null);
  1265.             }
  1266.         }
  1268.         return $this;
  1269.     }
  1271.     public function getClassLevel(): ?ClassLevel
  1272.     {
  1273.         return $this->classLevel;
  1274.     }
  1276.     public function setClassLevel(?ClassLevel $classLevel): static
  1277.     {
  1278.         $this->classLevel = $classLevel;
  1280.         return $this;
  1281.     }
  1283.     // ── ClassOptions (ManyToMany) ──────────────────────────────────────
  1285.     /**
  1286.      * @return Collection<int, ClassOption>
  1287.      */
  1288.     public function getClassOptions(): Collection
  1289.     {
  1290.         return $this->classOptions;
  1291.     }
  1293.     public function addClassOption(ClassOption $classOption): static
  1294.     {
  1295.         if (!$this->classOptions->contains($classOption)) {
  1296.             $this->classOptions->add($classOption);
  1297.             $classOption->addTheClass($this);
  1298.         }
  1299.         return $this;
  1300.     }
  1302.     public function removeClassOption(ClassOption $classOption): static
  1303.     {
  1304.         if ($this->classOptions->removeElement($classOption)) {
  1305.             $classOption->removeTheClass($this);
  1306.         }
  1307.         return $this;
  1308.     }
  1310.     /**
  1311.      * Compatibilité : retourne la première option si elle existe.
  1312.      * Utile pour les vues qui n'affichent qu'une option.
  1313.      */
  1314.     public function getClassOption(): ?ClassOption
  1315.     {
  1316.         return $this->classOptions->first() ?: null;
  1317.     }
  1319.     // ── NextClasses (promotion) ─────────────────────────────────────────
  1321.     /**
  1322.      * @return Collection<int, TheClass>
  1323.      */
  1324.     public function getNextClasses(): Collection
  1325.     {
  1326.         return $this->nextClasses;
  1327.     }
  1329.     public function addNextClass(TheClass $nextClass): static
  1330.     {
  1331.         if (!$this->nextClasses->contains($nextClass)) {
  1332.             $this->nextClasses->add($nextClass);
  1333.         }
  1334.         return $this;
  1335.     }
  1337.     public function removeNextClass(TheClass $nextClass): static
  1338.     {
  1339.         $this->nextClasses->removeElement($nextClass);
  1340.         return $this;
  1341.     }
  1343.     /**
  1344.      * Retourne true si cette classe a exactement 1 classe suivante
  1345.      * (promotion automatique possible).
  1346.      */
  1347.     public function hasSingleNextClass(): bool
  1348.     {
  1349.         return $this->nextClasses->count() === 1;
  1350.     }
  1351. }