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: AgendaDay::class)]
  141.     private Collection $agendaDays;
  143.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Competence::class)]
  144.     private Collection $competences;
  146.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: WeekSubjectGoal::class)]
  147.     private Collection $weekSubjectGoals;
  149.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: AgendaElement::class)]
  150.     private Collection $agendaElements;
  152.     public function __toString(): string
  153.     {
  154.         return $this->name;
  155.     }
  157.     public function __construct()
  158.     {
  159.         $this->subjects = new ArrayCollection();
  160.         $this->studentsYears = new ArrayCollection();
  161.         $this->homeWorks = new ArrayCollection();
  162.         $this->notes = new ArrayCollection();
  163.         $this->userYears = new ArrayCollection();
  164.         $this->docInfos = new ArrayCollection();
  165.         $this->discussionClasses = new ArrayCollection();
  166.         $this->subjectGroups = new ArrayCollection();
  167.         $this->scolarities = new ArrayCollection();
  168.         $this->subSequences = new ArrayCollection();
  169.         $this->quarters = new ArrayCollection();
  170.         $this->subNotes = new ArrayCollection();
  171.         $this->disciplineWarnings = new ArrayCollection();
  172.         $this->disciplineBlames = new ArrayCollection();
  173.         $this->disciplineExclusions = new ArrayCollection();
  174.         $this->parentNotes = new ArrayCollection();
  175.         $this->absences = new ArrayCollection();
  176.         $this->disciplineRetaineds = new ArrayCollection();
  177.         $this->primaryParentNotes = new ArrayCollection();
  178.         $this->primaryNotes = new ArrayCollection();
  179.         $this->punishes = new ArrayCollection();
  180.         $this->disciplinePunishes = new ArrayCollection();
  181.         $this->lates = new ArrayCollection();
  182.         $this->blames = new ArrayCollection();
  183.         $this->warnings = new ArrayCollection();
  184.         $this->retaineds = new ArrayCollection();
  185.         $this->disciplineConciles = new ArrayCollection();
  186.         $this->agendaDays = new ArrayCollection();
  187.         $this->competences = new ArrayCollection();
  188.         $this->weekSubjectGoals = new ArrayCollection();
  189.         $this->agendaElements = new ArrayCollection();
  190.     }
  192.     public function getId(): ?int
  193.     {
  194.         return $this->id;
  195.     }
  197.     public function getName(): ?string
  198.     {
  199.         return $this->name;
  200.     }
  202.     public function setName(string $name): static
  203.     {
  204.         $this->name = $name;
  206.         return $this;
  207.     }
  209.     public function getSection(): ?SchoolSection
  210.     {
  211.         return $this->section;
  212.     }
  214.     public function setSection(?SchoolSection $section): static
  215.     {
  216.         $this->section = $section;
  218.         return $this;
  219.     }
  221.     /**
  222.      * @return Collection<int, StudentYear>
  223.      */
  224.     public function getStudentsYears(): Collection
  225.     {
  226.         return $this->studentsYears;
  227.     }
  229.     public function addStudentsYear(StudentYear $studentsYear): static
  230.     {
  231.         if (!$this->studentsYears->contains($studentsYear)) {
  232.             $this->studentsYears->add($studentsYear);
  233.             $studentsYear->setClasse($this);
  234.         }
  236.         return $this;
  237.     }
  239.     public function removeStudentsYear(StudentYear $studentsYear): static
  240.     {
  241.         if ($this->studentsYears->removeElement($studentsYear)) {
  242.             // set the owning side to null (unless already changed)
  243.             if ($studentsYear->getClasse() === $this) {
  244.                 $studentsYear->setClasse(null);
  245.             }
  246.         }
  248.         return $this;
  249.     }
  251.     /**
  252.      * @return Collection<int, Subject>
  253.      */
  254.     public function getSubjects(): Collection
  255.     {
  256.         return $this->subjects;
  257.     }
  259.     public function addSubject(Subject $subject): static
  260.     {
  261.         if (!$this->subjects->contains($subject)) {
  262.             $this->subjects->add($subject);
  263.             $subject->setClasse($this);
  264.         }
  266.         return $this;
  267.     }
  269.     public function removeSubject(Subject $subject): static
  270.     {
  271.         if ($this->subjects->removeElement($subject)) {
  272.             // set the owning side to null (unless already changed)
  273.             if ($subject->getClasse() === $this) {
  274.                 $subject->setClasse(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     /**
  282.      * @return Collection<int, HomeWork>
  283.      */
  284.     public function getHomeWorks(): Collection
  285.     {
  286.         return $this->homeWorks;
  287.     }
  289.     public function addHomeWork(HomeWork $homeWork): static
  290.     {
  291.         if (!$this->homeWorks->contains($homeWork)) {
  292.             $this->homeWorks->add($homeWork);
  293.             $homeWork->setClasse($this);
  294.         }
  296.         return $this;
  297.     }
  299.     public function removeHomework(HomeWork $homeWork): static
  300.     {
  301.         if ($this->homeWorks->removeElement($homeWork)) {
  302.             // set the owning side to null (unless already changed)
  303.             if ($homeWork->getClasse() === $this) {
  304.                 $homeWork->setClasse(null);
  305.             }
  306.         }
  308.         return $this;
  309.     }
  311.     public function isActive(): ?bool
  312.     {
  313.         return $this->active;
  314.     }
  316.     public function setActive(?bool $active): static
  317.     {
  318.         $this->active = $active;
  320.         return $this;
  321.     }
  323.     /**
  324.      * @return Collection<int, Note>
  325.      */
  326.     public function getNotes(): Collection
  327.     {
  328.         return $this->notes;
  329.     }
  331.     public function addNote(Note $note): static
  332.     {
  333.         if (!$this->notes->contains($note)) {
  334.             $this->notes->add($note);
  335.             $note->setClasse($this);
  336.         }
  338.         return $this;
  339.     }
  341.     public function removeNote(Note $note): static
  342.     {
  343.         if ($this->notes->removeElement($note)) {
  344.             // set the owning side to null (unless already changed)
  345.             if ($note->getClasse() === $this) {
  346.                 $note->setClasse(null);
  347.             }
  348.         }
  350.         return $this;
  351.     }
  353.     /**
  354.      * @return Collection<int, UserYear>
  355.      */
  356.     public function getUserYears(): Collection
  357.     {
  358.         return $this->userYears;
  359.     }
  361.     public function addUserYear(UserYear $userYear): static
  362.     {
  363.         if (!$this->userYears->contains($userYear)) {
  364.             $this->userYears->add($userYear);
  365.             $userYear->addClass($this);
  366.         }
  368.         return $this;
  369.     }
  371.     public function removeUserYear(UserYear $userYear): static
  372.     {
  373.         if ($this->userYears->removeElement($userYear)) {
  374.             $userYear->removeClass($this);
  375.         }
  377.         return $this;
  378.     }
  380.     /**
  381.      * @return Collection<int, DocInfo>
  382.      */
  383.     public function getDocInfos(): Collection
  384.     {
  385.         return $this->docInfos;
  386.     }
  388.     public function addDocInfo(DocInfo $docInfo): static
  389.     {
  390.         if (!$this->docInfos->contains($docInfo)) {
  391.             $this->docInfos->add($docInfo);
  392.             $docInfo->addClass($this);
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeDocInfo(DocInfo $docInfo): static
  399.     {
  400.         if ($this->docInfos->removeElement($docInfo)) {
  401.             $docInfo->removeClass($this);
  402.         }
  404.         return $this;
  405.     }
  407.     public function getAuthor(): ?User
  408.     {
  409.         return $this->author;
  410.     }
  412.     public function setAuthor(?User $author): static
  413.     {
  414.         $this->author = $author;
  416.         return $this;
  417.     }
  419.     public function getEditor(): ?User
  420.     {
  421.         return $this->editor;
  422.     }
  424.     public function setEditor(?User $editor): static
  425.     {
  426.         $this->editor = $editor;
  428.         return $this;
  429.     }
  431.     public function getSchool(): ?School
  432.     {
  433.         return $this->school;
  434.     }
  436.     public function setSchool(?School $school): static
  437.     {
  438.         $this->school = $school;
  440.         return $this;
  441.     }
  443.     /**
  444.      * @return Collection<int, DiscussionClass>
  445.      */
  446.     public function getDiscussionClasses(): Collection
  447.     {
  448.         return $this->discussionClasses;
  449.     }
  451.     public function addDiscussionClass(DiscussionClass $discussionClass): static
  452.     {
  453.         if (!$this->discussionClasses->contains($discussionClass)) {
  454.             $this->discussionClasses->add($discussionClass);
  455.             $discussionClass->setClasse($this);
  456.         }
  458.         return $this;
  459.     }
  461.     public function removeDiscussionClass(DiscussionClass $discussionClass): static
  462.     {
  463.         if ($this->discussionClasses->removeElement($discussionClass)) {
  464.             // set the owning side to null (unless already changed)
  465.             if ($discussionClass->getClasse() === $this) {
  466.                 $discussionClass->setClasse(null);
  467.             }
  468.         }
  470.         return $this;
  471.     }
  473.     /**
  474.      * @return Collection<int, SubjectGroup>
  475.      */
  476.     public function getSubjectGroups(): Collection
  477.     {
  478.         return $this->subjectGroups;
  479.     }
  481.     public function addSubjectGroup(SubjectGroup $subjectGroup): static
  482.     {
  483.         if (!$this->subjectGroups->contains($subjectGroup)) {
  484.             $this->subjectGroups->add($subjectGroup);
  485.             $subjectGroup->setClasse($this);
  486.         }
  488.         return $this;
  489.     }
  491.     public function removeSubjectGroup(SubjectGroup $subjectGroup): static
  492.     {
  493.         if ($this->subjectGroups->removeElement($subjectGroup)) {
  494.             // set the owning side to null (unless already changed)
  495.             if ($subjectGroup->getClasse() === $this) {
  496.                 $subjectGroup->setClasse(null);
  497.             }
  498.         }
  500.         return $this;
  501.     }
  503.     /**
  504.      * @return Collection<int, Scolarity>
  505.      */
  506.     public function getScolarities(): Collection
  507.     {
  508.         return $this->scolarities;
  509.     }
  511.     public function addScolarity(Scolarity $scolarity): static
  512.     {
  513.         if (!$this->scolarities->contains($scolarity)) {
  514.             $this->scolarities->add($scolarity);
  515.             $scolarity->setClasse($this);
  516.         }
  518.         return $this;
  519.     }
  521.     public function removeScolarity(Scolarity $scolarity): static
  522.     {
  523.         if ($this->scolarities->removeElement($scolarity)) {
  524.             // set the owning side to null (unless already changed)
  525.             if ($scolarity->getClasse() === $this) {
  526.                 $scolarity->setClasse(null);
  527.             }
  528.         }
  530.         return $this;
  531.     }
  533.     /**
  534.      * @return Collection<int, ExamAgenda>
  535.      */
  536.     public function getExamAgendas(): Collection
  537.     {
  538.         return $this->examAgendas;
  539.     }
  541.     public function addExamAgenda(ExamAgenda $examAgenda): static
  542.     {
  543.         if (!$this->examAgendas->contains($examAgenda)) {
  544.             $this->examAgendas->add($examAgenda);
  545.             $examAgenda->setClasse($this);
  546.         }
  548.         return $this;
  549.     }
  551.     public function removeExamAgenda(ExamAgenda $examAgenda): static
  552.     {
  553.         if ($this->examAgendas->removeElement($examAgenda)) {
  554.             // set the owning side to null (unless already changed)
  555.             if ($examAgenda->getClasse() === $this) {
  556.                 $examAgenda->setClasse(null);
  557.             }
  558.         }
  560.         return $this;
  561.     }
  563.     /**
  564.      * @return Collection<int, SubSequence>
  565.      */
  566.     public function getSubSequences(): Collection
  567.     {
  568.         return $this->subSequences;
  569.     }
  571.     public function addSubSequence(SubSequence $subSequence): static
  572.     {
  573.         if (!$this->subSequences->contains($subSequence)) {
  574.             $this->subSequences->add($subSequence);
  575.             $subSequence->setClasse($this);
  576.         }
  578.         return $this;
  579.     }
  581.     public function removeSubSequence(SubSequence $subSequence): static
  582.     {
  583.         if ($this->subSequences->removeElement($subSequence)) {
  584.             // set the owning side to null (unless already changed)
  585.             if ($subSequence->getClasse() === $this) {
  586.                 $subSequence->setClasse(null);
  587.             }
  588.         }
  590.         return $this;
  591.     }
  593.     /**
  594.      * @return Collection<int, Quarter>
  595.      */
  596.     public function getQuarters(): Collection
  597.     {
  598.         return $this->quarters;
  599.     }
  601.     public function addQuarter(Quarter $quarter): static
  602.     {
  603.         if (!$this->quarters->contains($quarter)) {
  604.             $this->quarters->add($quarter);
  605.             $quarter->setClasse($this);
  606.         }
  608.         return $this;
  609.     }
  611.     public function removeQuarter(Quarter $quarter): static
  612.     {
  613.         if ($this->quarters->removeElement($quarter)) {
  614.             // set the owning side to null (unless already changed)
  615.             if ($quarter->getClasse() === $this) {
  616.                 $quarter->setClasse(null);
  617.             }
  618.         }
  620.         return $this;
  621.     }
  623.     /**
  624.      * @return Collection<int, SubNote>
  625.      */
  626.     public function getSubNotes(): Collection
  627.     {
  628.         return $this->subNotes;
  629.     }
  631.     public function addSubNote(SubNote $subNote): static
  632.     {
  633.         if (!$this->subNotes->contains($subNote)) {
  634.             $this->subNotes->add($subNote);
  635.             $subNote->setClasse($this);
  636.         }
  638.         return $this;
  639.     }
  641.     public function removeSubNote(SubNote $subNote): static
  642.     {
  643.         if ($this->subNotes->removeElement($subNote)) {
  644.             // set the owning side to null (unless already changed)
  645.             if ($subNote->getClasse() === $this) {
  646.                 $subNote->setClasse(null);
  647.             }
  648.         }
  650.         return $this;
  651.     }
  653.     /**
  654.      * @return Collection<int, Punish>
  655.      */
  656.     public function getPunishes(): Collection
  657.     {
  658.         return $this->punishes;
  659.     }
  661.     public function addPunish(Punish $punish): static
  662.     {
  663.         if (!$this->punishes->contains($punish)) {
  664.             $this->punishes->add($punish);
  665.             $punish->setClass($this);
  666.         }
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection<int, DisciplineWarning>
  672.      */
  673.     public function getDisciplineWarnings(): Collection
  674.     {
  675.         return $this->disciplineWarnings;
  676.     }
  678.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  679.     {
  680.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  681.             $this->disciplineWarnings->add($disciplineWarning);
  682.             $disciplineWarning->setClasse($this);
  683.         }
  685.         return $this;
  686.     }
  688.     public function removePunish(Punish $punish): static
  689.     {
  690.         if ($this->punishes->removeElement($punish)) {
  691.             // set the owning side to null (unless already changed)
  692.             if ($punish->getClass() === $this) {
  693.                 $punish->setClass(null);
  694.             }
  695.             return $this;
  696.         }
  697.     }
  698.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  699.     {
  700.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  701.             // set the owning side to null (unless already changed)
  702.             if ($disciplineWarning->getClasse() === $this) {
  703.                 $disciplineWarning->setClasse(null);
  704.             }
  705.         }
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, DisciplineBlame>
  712.      */
  713.     public function getDisciplineBlames(): Collection
  714.     {
  715.         return $this->disciplineBlames;
  716.     }
  718.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  719.     {
  720.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  721.             $this->disciplineBlames->add($disciplineBlame);
  722.             $disciplineBlame->setClasse($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  729.     {
  730.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($disciplineBlame->getClasse() === $this) {
  733.                 $disciplineBlame->setClasse(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     /**
  741.      * @return Collection<int, DisciplineExclusion>
  742.      */
  743.     public function getDisciplineExclusions(): Collection
  744.     {
  745.         return $this->disciplineExclusions;
  746.     }
  748.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  749.     {
  750.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  751.             $this->disciplineExclusions->add($disciplineExclusion);
  752.             $disciplineExclusion->setClasse($this);
  753.         }
  755.         return $this;
  756.     }
  758.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  759.     {
  760.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  761.             // set the owning side to null (unless already changed)
  762.             if ($disciplineExclusion->getClasse() === $this) {
  763.                 $disciplineExclusion->setClasse(null);
  764.             }
  765.         }
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, ParentNote>
  772.      */
  773.     public function getParentNotes(): Collection
  774.     {
  775.         return $this->parentNotes;
  776.     }
  778.     public function addParentNote(ParentNote $parentNote): static
  779.     {
  780.         if (!$this->parentNotes->contains($parentNote)) {
  781.             $this->parentNotes->add($parentNote);
  782.             $parentNote->setClasse($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeParentNote(ParentNote $parentNote): static
  789.     {
  790.         if ($this->parentNotes->removeElement($parentNote)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($parentNote->getClasse() === $this) {
  793.                 $parentNote->setClasse(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     /**
  801.      * @return Collection<int, Absence>
  802.      */
  803.     public function getAbsences(): Collection
  804.     {
  805.         return $this->absences;
  806.     }
  808.     public function addAbsence(Absence $absence): static
  809.     {
  810.         if (!$this->absences->contains($absence)) {
  811.             $this->absences->add($absence);
  812.             $absence->setClasse($this);
  813.         }
  815.         return $this;
  816.     }
  818.     public function removeAbsence(Absence $absence): static
  819.     {
  820.         if ($this->absences->removeElement($absence)) {
  821.             // set the owning side to null (unless already changed)
  822.             if ($absence->getClasse() === $this) {
  823.                 $absence->setClasse(null);
  824.             }
  825.         }
  827.         return $this;
  828.     }
  830.     /**
  831.      * @return Collection<int, DisciplineRetained>
  832.      */
  833.     public function getDisciplineRetaineds(): Collection
  834.     {
  835.         return $this->disciplineRetaineds;
  836.     }
  838.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  839.     {
  840.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  841.             $this->disciplineRetaineds->add($disciplineRetained);
  842.             $disciplineRetained->setClasse($this);
  843.         }
  845.         return $this;
  846.     }
  848.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  849.     {
  850.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  851.             // set the owning side to null (unless already changed)
  852.             if ($disciplineRetained->getClasse() === $this) {
  853.                 $disciplineRetained->setClasse(null);
  854.             }
  855.         }
  857.         return $this;
  858.     }
  860.     public function getProf(): ?User
  861.     {
  862.         return $this->prof;
  863.     }
  865.     public function setProf(?User $prof): static
  866.     {
  867.         $this->prof = $prof;
  869.         return $this;
  870.     }
  872.     /**
  873.      * @return Collection<int, PrimaryParentNote>
  874.      */
  875.     public function getPrimaryParentNotes(): Collection
  876.     {
  877.         return $this->primaryParentNotes;
  878.     }
  880.     public function addPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  881.     {
  882.         if (!$this->primaryParentNotes->contains($primaryParentNote)) {
  883.             $this->primaryParentNotes->add($primaryParentNote);
  884.             $primaryParentNote->setClasse($this);
  885.         }
  887.         return $this;
  888.     }
  890.     public function removePrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  891.     {
  892.         if ($this->primaryParentNotes->removeElement($primaryParentNote)) {
  893.             // set the owning side to null (unless already changed)
  894.             if ($primaryParentNote->getClasse() === $this) {
  895.                 $primaryParentNote->setClasse(null);
  896.             }
  897.         }
  899.         return $this;
  900.     }
  902.     /**
  903.      * @return Collection<int, PrimaryNote>
  904.      */
  905.     public function getPrimaryNotes(): Collection
  906.     {
  907.         return $this->primaryNotes;
  908.     }
  910.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  911.     {
  912.         if (!$this->primaryNotes->contains($primaryNote)) {
  913.             $this->primaryNotes->add($primaryNote);
  914.             $primaryNote->setClasse($this);
  915.         }
  917.         return $this;
  918.     }
  920.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  921.     {
  922.         if ($this->primaryNotes->removeElement($primaryNote)) {
  923.             // set the owning side to null (unless already changed)
  924.             if ($primaryNote->getClasse() === $this) {
  925.                 $primaryNote->setClasse(null);
  926.             }
  927.         }
  929.         return $this;
  930.     }
  932.     /**
  933.      * @return Collection<int, DisciplinePunish>
  934.      */
  935.     public function getDisciplinePunishes(): Collection
  936.     {
  937.         return $this->disciplinePunishes;
  938.     }
  940.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  941.     {
  942.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  943.             $this->disciplinePunishes->add($disciplinePunish);
  944.             $disciplinePunish->setClasse($this);
  945.         }
  947.         return $this;
  948.     }
  950.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  951.     {
  952.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  953.             // set the owning side to null (unless already changed)
  954.             if ($disciplinePunish->getClasse() === $this) {
  955.                 $disciplinePunish->setClasse(null);
  956.             }
  957.         }
  959.         return $this;
  960.     }
  962.     /**
  963.      * @return Collection<int, Late>
  964.      */
  965.     public function getLates(): Collection
  966.     {
  967.         return $this->lates;
  968.     }
  970.     public function addLate(Late $late): static
  971.     {
  972.         if (!$this->lates->contains($late)) {
  973.             $this->lates->add($late);
  974.             $late->setClasse($this);
  975.         }
  977.         return $this;
  978.     }
  980.     public function removeLate(Late $late): static
  981.     {
  982.         if ($this->lates->removeElement($late)) {
  983.             // set the owning side to null (unless already changed)
  984.             if ($late->getClasse() === $this) {
  985.                 $late->setClasse(null);
  986.             }
  987.         }
  989.         return $this;
  990.     }
  992.     /**
  993.      * @return Collection<int, Blame>
  994.      */
  995.     public function getBlames(): Collection
  996.     {
  997.         return $this->blames;
  998.     }
  1000.     public function addBlame(Blame $blame): static
  1001.     {
  1002.         if (!$this->blames->contains($blame)) {
  1003.             $this->blames->add($blame);
  1004.             $blame->setClasse($this);
  1005.         }
  1007.         return $this;
  1008.     }
  1010.     public function removeBlame(Blame $blame): static
  1011.     {
  1012.         if ($this->blames->removeElement($blame)) {
  1013.             // set the owning side to null (unless already changed)
  1014.             if ($blame->getClasse() === $this) {
  1015.                 $blame->setClasse(null);
  1016.             }
  1017.         }
  1019.         return $this;
  1020.     }
  1022.     /**
  1023.      * @return Collection<int, Warning>
  1024.      */
  1025.     public function getWarnings(): Collection
  1026.     {
  1027.         return $this->warnings;
  1028.     }
  1030.     public function addWarning(Warning $warning): static
  1031.     {
  1032.         if (!$this->warnings->contains($warning)) {
  1033.             $this->warnings->add($warning);
  1034.             $warning->setClasse($this);
  1035.         }
  1037.         return $this;
  1038.     }
  1040.     public function removeWarning(Warning $warning): static
  1041.     {
  1042.         if ($this->warnings->removeElement($warning)) {
  1043.             // set the owning side to null (unless already changed)
  1044.             if ($warning->getClasse() === $this) {
  1045.                 $warning->setClasse(null);
  1046.             }
  1047.         }
  1049.         return $this;
  1050.     }
  1052.     /**
  1053.      * @return Collection<int, Retained>
  1054.      */
  1055.     public function getRetaineds(): Collection
  1056.     {
  1057.         return $this->retaineds;
  1058.     }
  1060.     public function addRetained(Retained $retained): static
  1061.     {
  1062.         if (!$this->retaineds->contains($retained)) {
  1063.             $this->retaineds->add($retained);
  1064.             $retained->setClasse($this);
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     public function removeRetained(Retained $retained): static
  1071.     {
  1072.         if ($this->retaineds->removeElement($retained)) {
  1073.             // set the owning side to null (unless already changed)
  1074.             if ($retained->getClasse() === $this) {
  1075.                 $retained->setClasse(null);
  1076.             }
  1077.         }
  1079.         return $this;
  1080.     }
  1082.     public function getSlug(): ?string
  1083.     {
  1084.         return $this->slug;
  1085.     }
  1087.     public function setSlug(?string $slug): static
  1088.     {
  1089.         $this->slug = $slug;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, DisciplineConcile>
  1096.      */
  1097.     public function getDisciplineConciles(): Collection
  1098.     {
  1099.         return $this->disciplineConciles;
  1100.     }
  1102.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1103.     {
  1104.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  1105.             $this->disciplineConciles->add($disciplineConcile);
  1106.             $disciplineConcile->setClasse($this);
  1107.         }
  1109.         return $this;
  1110.     }
  1112.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  1113.     {
  1114.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  1115.             // set the owning side to null (unless already changed)
  1116.             if ($disciplineConcile->getClasse() === $this) {
  1117.                 $disciplineConcile->setClasse(null);
  1118.             }
  1119.         }
  1121.         return $this;
  1122.     }
  1124.     public function getPrincipalProf(): ?UserYear
  1125.     {
  1126.         return $this->principalProf;
  1127.     }
  1129.     public function setPrincipalProf(?UserYear $principalProf): static
  1130.     {
  1131.         $this->principalProf = $principalProf;
  1133.         return $this;
  1134.     }
  1136.     /**
  1137.      * @return Collection<int, AgendaDay>
  1138.      */
  1139.     public function getAgendaDays(): Collection
  1140.     {
  1141.         return $this->agendaDays;
  1142.     }
  1144.     public function addAgendaDay(AgendaDay $agendaDay): static
  1145.     {
  1146.         if (!$this->agendaDays->contains($agendaDay)) {
  1147.             $this->agendaDays->add($agendaDay);
  1148.             $agendaDay->setClasse($this);
  1149.         }
  1151.         return $this;
  1152.     }
  1154.     public function removeAgendaDay(AgendaDay $agendaDay): static
  1155.     {
  1156.         if ($this->agendaDays->removeElement($agendaDay)) {
  1157.             // set the owning side to null (unless already changed)
  1158.             if ($agendaDay->getClasse() === $this) {
  1159.                 $agendaDay->setClasse(null);
  1160.             }
  1161.         }
  1163.         return $this;
  1164.     }
  1166.     /**
  1167.      * @return Collection<int, Competence>
  1168.      */
  1169.     public function getCompetences(): Collection
  1170.     {
  1171.         return $this->competences;
  1172.     }
  1174.     public function addCompetence(Competence $competence): static
  1175.     {
  1176.         if (!$this->competences->contains($competence)) {
  1177.             $this->competences->add($competence);
  1178.             $competence->setClasse($this);
  1179.         }
  1181.         return $this;
  1182.     }
  1184.     public function removeCompetence(Competence $competence): static
  1185.     {
  1186.         if ($this->competences->removeElement($competence)) {
  1187.             // set the owning side to null (unless already changed)
  1188.             if ($competence->getClasse() === $this) {
  1189.                 $competence->setClasse(null);
  1190.             }
  1191.         }
  1193.         return $this;
  1194.     }
  1196.     /**
  1197.      * @return Collection<int, WeekSubjectGoal>
  1198.      */
  1199.     public function getWeekSubjectGoals(): Collection
  1200.     {
  1201.         return $this->weekSubjectGoals;
  1202.     }
  1204.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1205.     {
  1206.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  1207.             $this->weekSubjectGoals->add($weekSubjectGoal);
  1208.             $weekSubjectGoal->setClasse($this);
  1209.         }
  1211.         return $this;
  1212.     }
  1214.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  1215.     {
  1216.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  1217.             // set the owning side to null (unless already changed)
  1218.             if ($weekSubjectGoal->getClasse() === $this) {
  1219.                 $weekSubjectGoal->setClasse(null);
  1220.             }
  1221.         }
  1223.         return $this;
  1224.     }
  1226.     /**
  1227.      * @return Collection<int, AgendaElement>
  1228.      */
  1229.     public function getAgendaElements(): Collection
  1230.     {
  1231.         return $this->agendaElements;
  1232.     }
  1234.     public function addAgendaElement(AgendaElement $agendaElement): static
  1235.     {
  1236.         if (!$this->agendaElements->contains($agendaElement)) {
  1237.             $this->agendaElements->add($agendaElement);
  1238.             $agendaElement->setClasse($this);
  1239.         }
  1241.         return $this;
  1242.     }
  1244.     public function removeAgendaElement(AgendaElement $agendaElement): static
  1245.     {
  1246.         if ($this->agendaElements->removeElement($agendaElement)) {
  1247.             // set the owning side to null (unless already changed)
  1248.             if ($agendaElement->getClasse() === $this) {
  1249.                 $agendaElement->setClasse(null);
  1250.             }
  1251.         }
  1253.         return $this;
  1254.     }
  1255. }