src/Entity/Subject.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SubjectRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use App\Entity\Traits\Timestampable;
  10. use JMS\Serializer\Annotation\Groups;
  12. #[ORM\HasLifecycleCallbacks]
  13. #[ORM\Entity(repositoryClass: SubjectRepository::class)]
  14. class Subject
  15. {
  16.     use Timestampable;
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     #[Groups(['getAbsence','homework','note','getBulletin', 'getAgenda', 'getExamAgenda'])]
  21.     private ?int $id = null;
  23.     #[ORM\Column(length: 255)]
  24.     #[Groups(['getAbsence','homework','note','getBulletin','getDiscussion', 'getAgenda', 'getExamAgenda'])]
  25.     private ?string $name = null;
  27.     #[ORM\Column]
  28.     #[Groups(['getBulletin','getSubject'])]
  29.     private ?float $coef = null;
  31.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  32.     #[Groups(["getSubject"])]
  33.     private ?TheClass $classe = null;
  35.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  36.     #[Groups(["getSubject"])]
  37.     private ?User $prof = null;
  39.     #[ORM\Column]
  40.     private ?bool $active = null;
  42.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: HomeWork::class)]
  43.     private Collection $homeWorks;
  45.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Absence::class)]
  46.     private Collection $absences;
  48.     /**
  49.      * Cahier de texte : entrées (avec ou sans chapitre du programme
  50.      * national) saisies par le prof pour cette matière réelle.
  51.      */
  52.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: LessonLog::class, cascade: ['remove'], orphanRemoval: true)]
  53.     #[ORM\OrderBy(['date' => 'DESC'])]
  54.     private Collection $lessonLogs;
  56.     #[ORM\ManyToOne(inversedBy: 'subjects', cascade: ["persist"])]
  57.     #[ORM\JoinColumn(nullable: false)]
  58.     private ?SubjectGroup $subjectGroup = null;
  60.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Note::class)]
  61.     private Collection $notes;
  63.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Exams::class)]
  64.     private Collection $exams;
  66.     #[ORM\ManyToOne(inversedBy: 'subjectsEdited', cascade: ["persist"])]
  67.     private ?User $editor = null;
  69.     #[ORM\ManyToOne(inversedBy: 'subjectsCreated', cascade: ["persist"])]
  70.     private ?User $author = null;
  72.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  73.     #[Groups(['getSubject'])]
  74.     private ?School $school = null;
  76.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: AgendaElement::class)]
  77.     private Collection $agendaElements;
  79.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ExamAgendaElement::class)]
  80.     private Collection $examAgendaElements;
  82.     #[Groups(['getAbsence','homework','note','getBulletin','getDiscussion', 'getAgenda', 'getExamAgenda'])]
  83.     #[ORM\Column(length: 255, nullable: true)]
  84.     private ?string $competence = null;
  86.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ParentNote::class)]
  87.     private Collection $parentNotes;
  89.     #[ORM\ManyToOne(inversedBy: 'subjects')]
  90.     private ?SchoolYear $year = null;
  92.     #[ORM\OneToOne(mappedBy: 'subject', cascade: ['persist', 'remove'])]
  93.     private ?PrimaryParentNote $primaryParentNote = null;
  95.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: PrimaryNote::class)]
  96.     private Collection $primaryNotes;
  98.     #[ORM\Column(nullable: true)]
  99.     private ?float $point = null;
  101.     #[ORM\Column(nullable: true)]
  102.     private ?float $totalPoints = null;
  103.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: SubNote::class, orphanRemoval: true)]
  104.     private Collection $subNotes;
  106.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Competence::class, cascade: ["persist", "remove"], orphanRemoval: true)]
  107.     private Collection $competences;
  109.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: WeekSubjectGoal::class)]
  110.     private Collection $weekSubjectGoals;
  112.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfSchoolPlanner::class)]
  113.     private Collection $profSchoolPlanners;
  115.     #[ORM\Column(nullable: true)]
  116.     private ?float $longitude = null;
  118.     #[ORM\Column(nullable: true)]
  119.     private ?float $latitude = null;
  121.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfTime::class)]
  122.     private Collection $profTimes;
  124.     /**
  125.      * Progression des chapitres du programme national pour ce Subject
  126.      * réel (matière + classe + école + année). 1 entrée par Chapter.
  127.      */
  128.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ChapterProgress::class, orphanRemoval: true)]
  129.     private Collection $chapterProgresses;
  131.     #[ORM\ManyToOne(inversedBy: 'subjects')]
  132.     private ?SubjectReference $reference = null;
  134.     public function __toString():string
  135.     {
  136.         return $this->name;
  137.     }
  139.     public function __construct()
  140.     {
  141.         $this->homeWorks = new ArrayCollection();
  142.         $this->absences = new ArrayCollection();
  143.         $this->lessonLogs = new ArrayCollection();
  144.         $this->notes = new ArrayCollection();
  145.         $this->exams = new ArrayCollection();
  146.         $this->agendaElements = new ArrayCollection();
  147.         $this->examAgendaElements = new ArrayCollection();
  148.         $this->parentNotes = new ArrayCollection();
  149.         $this->primaryNotes = new ArrayCollection();
  150.         $this->subNotes = new ArrayCollection();
  151.         $this->competences = new ArrayCollection();
  152.         $this->weekSubjectGoals = new ArrayCollection();
  153.         $this->profSchoolPlanners = new ArrayCollection();
  154.         $this->profTimes = new ArrayCollection();
  155.         $this->chapterProgresses = new ArrayCollection();
  156.     }
  158.     public function getId(): ?int
  159.     {
  160.         return $this->id;
  161.     }
  163.     public function getName(): ?string
  164.     {
  165.         return $this->name;
  166.     }
  168.     public function setName(string $name): static
  169.     {
  170.         $this->name = $name;
  172.         return $this;
  173.     }
  175.     public function getCoef(): ?float
  176.     {
  177.         return $this->coef;
  178.     }
  180.     public function setCoef(float $coef): static
  181.     {
  182.         $this->coef = $coef;
  184.         return $this;
  185.     }
  187.     public function getClasse(): ?TheClass
  188.     {
  189.         return $this->classe;
  190.     }
  192.     public function setClasse(?TheClass $classe): static
  193.     {
  194.         $this->classe = $classe;
  196.         return $this;
  197.     }
  199.     public function getProf(): ?User
  200.     {
  201.         return $this->prof;
  202.     }
  204.     public function setProf(?User $prof): static
  205.     {
  206.         $this->prof = $prof;
  208.         return $this;
  209.     }
  211.     public function isActive(): ?bool
  212.     {
  213.         return $this->active;
  214.     }
  216.     public function setActive(bool $active): static
  217.     {
  218.         $this->active = $active;
  220.         return $this;
  221.     }
  223.     /**
  224.      * @return Collection<int, HomeWork>
  225.      */
  226.     public function getHomeWorks(): Collection
  227.     {
  228.         return $this->homeWorks;
  229.     }
  231.     public function addHomeWork(HomeWork $homeWork): static
  232.     {
  233.         if (!$this->homeWorks->contains($homeWork)) {
  234.             $this->homeWorks->add($homeWork);
  235.             $homeWork->setSubject($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function removeHomeWork(HomeWork $homeWork): static
  242.     {
  243.         if ($this->homeWorks->removeElement($homeWork)) {
  244.             // set the owning side to null (unless already changed)
  245.             if ($homeWork->getSubject() === $this) {
  246.                 $homeWork->setSubject(null);
  247.             }
  248.         }
  250.         return $this;
  251.     }
  253.     /**
  254.      * @return Collection<int, Absence>
  255.      */
  256.     public function getAbsences(): Collection
  257.     {
  258.         return $this->absences;
  259.     }
  261.     public function addAbsence(Absence $absence): static
  262.     {
  263.         if (!$this->absences->contains($absence)) {
  264.             $this->absences->add($absence);
  265.             $absence->setSubject($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeAbsence(Absence $absence): static
  272.     {
  273.         if ($this->absences->removeElement($absence)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($absence->getSubject() === $this) {
  276.                 $absence->setSubject(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.     /**
  284.      * @return Collection<int, LessonLog>
  285.      */
  286.     public function getLessonLogs(): Collection
  287.     {
  288.         return $this->lessonLogs;
  289.     }
  291.     public function addLessonLog(LessonLog $lessonLog): static
  292.     {
  293.         if (!$this->lessonLogs->contains($lessonLog)) {
  294.             $this->lessonLogs->add($lessonLog);
  295.             $lessonLog->setSubject($this);
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeLessonLog(LessonLog $lessonLog): static
  302.     {
  303.         if ($this->lessonLogs->removeElement($lessonLog)) {
  304.             if ($lessonLog->getSubject() === $this) {
  305.                 $lessonLog->setSubject(null);
  306.             }
  307.         }
  309.         return $this;
  310.     }
  312.     public function getSubjectGroup(): ?SubjectGroup
  313.     {
  314.         return $this->subjectGroup;
  315.     }
  317.     public function setSubjectGroup(?SubjectGroup $subjectGroup): static
  318.     {
  319.         $this->subjectGroup = $subjectGroup;
  321.         return $this;
  322.     }
  324.     /**
  325.      * @return Collection<int, Note>
  326.      */
  327.     public function getNotes(): Collection
  328.     {
  329.         return $this->notes;
  330.     }
  332.     public function addNote(Note $note): static
  333.     {
  334.         if (!$this->notes->contains($note)) {
  335.             $this->notes->add($note);
  336.             $note->setSubject($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function removeNote(Note $note): static
  343.     {
  344.         if ($this->notes->removeElement($note)) {
  345.             // set the owning side to null (unless already changed)
  346.             if ($note->getSubject() === $this) {
  347.                 $note->setSubject(null);
  348.             }
  349.         }
  351.         return $this;
  352.     }
  354.     /**
  355.      * @return Collection<int, Exams>
  356.      */
  357.     public function getExams(): Collection
  358.     {
  359.         return $this->exams;
  360.     }
  362.     public function addExam(Exams $exam): static
  363.     {
  364.         if (!$this->exams->contains($exam)) {
  365.             $this->exams->add($exam);
  366.             $exam->setSubject($this);
  367.         }
  369.         return $this;
  370.     }
  372.     public function removeExam(Exams $exam): static
  373.     {
  374.         if ($this->exams->removeElement($exam)) {
  375.             // set the owning side to null (unless already changed)
  376.             if ($exam->getSubject() === $this) {
  377.                 $exam->setSubject(null);
  378.             }
  379.         }
  381.         return $this;
  382.     }
  384.     public function getEditor(): ?User
  385.     {
  386.         return $this->editor;
  387.     }
  389.     public function setEditor(?User $editor): static
  390.     {
  391.         $this->editor = $editor;
  393.         return $this;
  394.     }
  396.     public function getAuthor(): ?User
  397.     {
  398.         return $this->author;
  399.     }
  401.     public function setAuthor(?User $author): static
  402.     {
  403.         $this->author = $author;
  405.         return $this;
  406.     }
  408.     public function getSchool(): ?School
  409.     {
  410.         return $this->school;
  411.     }
  413.     public function setSchool(?School $school): static
  414.     {
  415.         $this->school = $school;
  417.         return $this;
  418.     }
  420.     /**
  421.      * @return Collection<int, AgendaElement>
  422.      */
  423.     public function getAgendaElements(): Collection
  424.     {
  425.         return $this->agendaElements;
  426.     }
  428.     public function addAgendaElement(AgendaElement $agendaElement): static
  429.     {
  430.         if (!$this->agendaElements->contains($agendaElement)) {
  431.             $this->agendaElements->add($agendaElement);
  432.             $agendaElement->setSubject($this);
  433.         }
  435.         return $this;
  436.     }
  438.     public function removeAgendaElement(AgendaElement $agendaElement): static
  439.     {
  440.         if ($this->agendaElements->removeElement($agendaElement)) {
  441.             // set the owning side to null (unless already changed)
  442.             if ($agendaElement->getSubject() === $this) {
  443.                 $agendaElement->setSubject(null);
  444.             }
  445.         }
  447.         return $this;
  448.     }
  450.     /**
  451.      * @return Collection<int, ExamAgendaElement>
  452.      */
  453.     public function getExamAgendaElements(): Collection
  454.     {
  455.         return $this->examAgendaElements;
  456.     }
  458.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  459.     {
  460.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  461.             $this->examAgendaElements->add($examAgendaElement);
  462.             $examAgendaElement->setSubject($this);
  463.         }
  465.         return $this;
  466.     }
  468.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  469.     {
  470.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  471.             // set the owning side to null (unless already changed)
  472.             if ($examAgendaElement->getSubject() === $this) {
  473.                 $examAgendaElement->setSubject(null);
  474.             }
  475.         }
  477.         return $this;
  478.     }
  480.     public function getCompetence(): ?string
  481.     {
  482.         return $this->competence;
  483.     }
  485.     public function setCompetence(?string $competence): static
  486.     {
  487.         $this->competence = $competence;
  489.         return $this;
  490.     }
  492.     /**
  493.      * @return Collection<int, ParentNote>
  494.      */
  495.     public function getParentNotes(): Collection
  496.     {
  497.         return $this->parentNotes;
  498.     }
  500.     public function addParentNote(ParentNote $parentNote): static
  501.     {
  502.         if (!$this->parentNotes->contains($parentNote)) {
  503.             $this->parentNotes->add($parentNote);
  504.             $parentNote->setSubject($this);
  505.         }
  506.         return $this;
  507.     }
  509.     /* 
  510.         @return Collection<int, SubNote>
  511.      */
  512.     public function getSubNotes(): Collection
  513.     {
  514.         return $this->subNotes;
  515.     }
  517.     public function addSubNote(SubNote $subNote): static
  518.     {
  519.         if (!$this->subNotes->contains($subNote)) {
  520.             $this->subNotes->add($subNote);
  521.             $subNote->setSubject($this);
  522.         }
  524.         return $this;
  525.     }
  527.     public function removeParentNote(ParentNote $parentNote): static
  528.     {
  529.         if ($this->parentNotes->removeElement($parentNote)) {
  530.             // set the owning side to null (unless already changed)
  531.             if ($parentNote->getSubject() === $this) {
  532.                 $parentNote->setSubject(null);
  533.             }
  534.         }
  535.         return $this;
  536.     }
  537.     public function removeSubNote(SubNote $subNote): static
  538.     {
  539.         if ($this->subNotes->removeElement($subNote)) {
  540.             // set the owning side to null (unless already changed)
  541.             if ($subNote->getSubject() === $this) {
  542.                 $subNote->setSubject(null);
  543.             }
  544.         }
  546.         return $this;
  547.     }
  549.     public function getYear(): ?SchoolYear
  550.     {
  551.         return $this->year;
  552.     }
  554.     public function setYear(?SchoolYear $year): static
  555.     {
  556.         $this->year = $year;
  558.         return $this;
  559.     }
  561.     public function getPrimaryParentNote(): ?PrimaryParentNote
  562.     {
  563.         return $this->primaryParentNote;
  564.     }
  566.     public function setPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  567.     {
  568.         // set the owning side of the relation if necessary
  569.         if ($primaryParentNote->getSubject() !== $this) {
  570.             $primaryParentNote->setSubject($this);
  571.         }
  573.         $this->primaryParentNote = $primaryParentNote;
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection<int, PrimaryNote>
  580.      */
  581.     public function getPrimaryNotes(): Collection
  582.     {
  583.         return $this->primaryNotes;
  584.     }
  586.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  587.     {
  588.         if (!$this->primaryNotes->contains($primaryNote)) {
  589.             $this->primaryNotes->add($primaryNote);
  590.             $primaryNote->setSubject($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  597.     {
  598.         if ($this->primaryNotes->removeElement($primaryNote)) {
  599.             // set the owning side to null (unless already changed)
  600.             if ($primaryNote->getSubject() === $this) {
  601.                 $primaryNote->setSubject(null);
  602.             }
  603.         }
  605.         return $this;
  606.     }
  608.     public function getPoint(): ?float
  609.     {
  610.         return $this->point;
  611.     }
  613.     public function setPoint(?float $point): static
  614.     {
  615.         $this->point = $point;
  617.         return $this;
  618.     }
  620.     public function getTotalPoints(): ?float
  621.     {
  622.         return $this->totalPoints;
  623.     }
  625.     public function setTotalPoints(?float $totalPoints): static
  626.     {
  627.         $this->totalPoints = $totalPoints;
  629.         return $this;
  630.     }
  632.     /**
  633.      * @return Collection<int, Competence>
  634.      */
  635.     public function getCompetences(): Collection
  636.     {
  637.         return $this->competences;
  638.     }
  640.     public function addCompetence(Competence $competence): static
  641.     {
  642.         if (!$this->competences->contains($competence)) {
  643.             $this->competences->add($competence);
  644.             $competence->setSubject($this);
  645.         }
  647.         return $this;
  648.     }
  650.     public function removeCompetence(Competence $competence): static
  651.     {
  652.         if ($this->competences->removeElement($competence)) {
  653.             // set the owning side to null (unless already changed)
  654.             if ($competence->getSubject() === $this) {
  655.                 $competence->setSubject(null);
  656.             }
  657.         }
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return Collection<int, WeekSubjectGoal>
  664.      */
  665.     public function getWeekSubjectGoals(): Collection
  666.     {
  667.         return $this->weekSubjectGoals;
  668.     }
  670.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  671.     {
  672.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  673.             $this->weekSubjectGoals->add($weekSubjectGoal);
  674.             $weekSubjectGoal->setSubject($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  681.     {
  682.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  683.             // set the owning side to null (unless already changed)
  684.             if ($weekSubjectGoal->getSubject() === $this) {
  685.                 $weekSubjectGoal->setSubject(null);
  686.             }
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * @return Collection<int, ProfSchoolPlanner>
  694.      */
  695.     public function getProfSchoolPlanners(): Collection
  696.     {
  697.         return $this->profSchoolPlanners;
  698.     }
  700.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  701.     {
  702.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  703.             $this->profSchoolPlanners->add($profSchoolPlanner);
  704.             $profSchoolPlanner->setSubject($this);
  705.         }
  707.         return $this;
  708.     }
  710.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  711.     {
  712.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  713.             // set the owning side to null (unless already changed)
  714.             if ($profSchoolPlanner->getSubject() === $this) {
  715.                 $profSchoolPlanner->setSubject(null);
  716.             }
  717.         }
  719.         return $this;
  720.     }
  722.     public function getLongitude(): ?float
  723.     {
  724.         return $this->longitude;
  725.     }
  727.     public function setLongitude(?float $longitude): static
  728.     {
  729.         $this->longitude = $longitude;
  731.         return $this;
  732.     }
  734.     public function getLatitude(): ?float
  735.     {
  736.         return $this->latitude;
  737.     }
  739.     public function setLatitude(?float $latitude): static
  740.     {
  741.         $this->latitude = $latitude;
  743.         return $this;
  744.     }
  746.     /**
  747.      * @return Collection<int, ProfTime>
  748.      */
  749.     public function getProfTimes(): Collection
  750.     {
  751.         return $this->profTimes;
  752.     }
  754.     public function addProfTime(ProfTime $profTime): static
  755.     {
  756.         if (!$this->profTimes->contains($profTime)) {
  757.             $this->profTimes->add($profTime);
  758.             $profTime->setSubject($this);
  759.         }
  761.         return $this;
  762.     }
  764.     public function removeProfTime(ProfTime $profTime): static
  765.     {
  766.         if ($this->profTimes->removeElement($profTime)) {
  767.             // set the owning side to null (unless already changed)
  768.             if ($profTime->getSubject() === $this) {
  769.                 $profTime->setSubject(null);
  770.             }
  771.         }
  773.         return $this;
  774.     }
  776.     /**
  777.      * @return Collection<int, ChapterProgress>
  778.      */
  779.     public function getChapterProgresses(): Collection
  780.     {
  781.         return $this->chapterProgresses;
  782.     }
  784.     public function addChapterProgress(ChapterProgress $chapterProgress): static
  785.     {
  786.         if (!$this->chapterProgresses->contains($chapterProgress)) {
  787.             $this->chapterProgresses->add($chapterProgress);
  788.             $chapterProgress->setSubject($this);
  789.         }
  791.         return $this;
  792.     }
  794.     public function removeChapterProgress(ChapterProgress $chapterProgress): static
  795.     {
  796.         if ($this->chapterProgresses->removeElement($chapterProgress)) {
  797.             if ($chapterProgress->getSubject() === $this) {
  798.                 $chapterProgress->setSubject(null);
  799.             }
  800.         }
  802.         return $this;
  803.     }
  805.     public function getReference(): ?SubjectReference
  806.     {
  807.         return $this->reference;
  808.     }
  810.     public function setReference(?SubjectReference $reference): static
  811.     {
  812.         $this->reference = $reference;
  814.         return $this;
  815.     }
  816. }