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.     /**
  32.      * Horaire hebdomadaire (nombre d'heures de cours par semaine), facultatif.
  33.      */
  34.     #[ORM\Column(nullable: true)]
  35.     #[Groups(['getSubject'])]
  36.     private ?float $horaire = null;
  38.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  39.     #[Groups(["getSubject"])]
  40.     private ?TheClass $classe = null;
  42.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  43.     #[Groups(["getSubject"])]
  44.     private ?User $prof = null;
  46.     #[ORM\Column]
  47.     private ?bool $active = null;
  49.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: HomeWork::class)]
  50.     private Collection $homeWorks;
  52.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Absence::class)]
  53.     private Collection $absences;
  55.     /**
  56.      * Cahier de texte : entrées (avec ou sans leçon du programme
  57.      * national) saisies par le prof pour cette matière réelle.
  58.      */
  59.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: LessonLog::class, cascade: ['remove'], orphanRemoval: true)]
  60.     #[ORM\OrderBy(['date' => 'DESC'])]
  61.     private Collection $lessonLogs;
  63.     #[ORM\ManyToOne(inversedBy: 'subjects', cascade: ["persist"])]
  64.     #[ORM\JoinColumn(nullable: false)]
  65.     private ?SubjectGroup $subjectGroup = null;
  67.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Note::class)]
  68.     private Collection $notes;
  70.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Exams::class)]
  71.     private Collection $exams;
  73.     #[ORM\ManyToOne(inversedBy: 'subjectsEdited', cascade: ["persist"])]
  74.     private ?User $editor = null;
  76.     #[ORM\ManyToOne(inversedBy: 'subjectsCreated', cascade: ["persist"])]
  77.     private ?User $author = null;
  79.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  80.     #[Groups(['getSubject'])]
  81.     private ?School $school = null;
  83.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: AgendaElement::class)]
  84.     private Collection $agendaElements;
  86.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ExamAgendaElement::class)]
  87.     private Collection $examAgendaElements;
  89.     #[Groups(['getAbsence','homework','note','getBulletin','getDiscussion', 'getAgenda', 'getExamAgenda'])]
  90.     #[ORM\Column(length: 255, nullable: true)]
  91.     private ?string $competence = null;
  93.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ParentNote::class)]
  94.     private Collection $parentNotes;
  96.     #[ORM\ManyToOne(inversedBy: 'subjects')]
  97.     private ?SchoolYear $year = null;
  99.     #[ORM\OneToOne(mappedBy: 'subject', cascade: ['persist', 'remove'])]
  100.     private ?PrimaryParentNote $primaryParentNote = null;
  102.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: PrimaryNote::class)]
  103.     private Collection $primaryNotes;
  105.     #[ORM\Column(nullable: true)]
  106.     private ?float $point = null;
  108.     #[ORM\Column(nullable: true)]
  109.     private ?float $totalPoints = null;
  110.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: SubNote::class, orphanRemoval: true)]
  111.     private Collection $subNotes;
  113.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Competence::class, cascade: ["persist", "remove"], orphanRemoval: true)]
  114.     private Collection $competences;
  116.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: WeekSubjectGoal::class)]
  117.     private Collection $weekSubjectGoals;
  119.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfSchoolPlanner::class)]
  120.     private Collection $profSchoolPlanners;
  122.     #[ORM\Column(nullable: true)]
  123.     private ?float $longitude = null;
  125.     #[ORM\Column(nullable: true)]
  126.     private ?float $latitude = null;
  128.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfTime::class)]
  129.     private Collection $profTimes;
  131.     /**
  132.      * Progression des leçons du programme national pour ce Subject
  133.      * réel (matière + classe + école + année). 1 entrée par Lesson.
  134.      */
  135.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: LessonProgress::class, orphanRemoval: true)]
  136.     private Collection $lessonProgresses;
  138.     #[ORM\ManyToOne(inversedBy: 'subjects')]
  139.     private ?SubjectReference $reference = null;
  141.     public function __toString():string
  142.     {
  143.         return $this->name;
  144.     }
  146.     public function __construct()
  147.     {
  148.         $this->homeWorks = new ArrayCollection();
  149.         $this->absences = new ArrayCollection();
  150.         $this->lessonLogs = new ArrayCollection();
  151.         $this->notes = new ArrayCollection();
  152.         $this->exams = new ArrayCollection();
  153.         $this->agendaElements = new ArrayCollection();
  154.         $this->examAgendaElements = new ArrayCollection();
  155.         $this->parentNotes = new ArrayCollection();
  156.         $this->primaryNotes = new ArrayCollection();
  157.         $this->subNotes = new ArrayCollection();
  158.         $this->competences = new ArrayCollection();
  159.         $this->weekSubjectGoals = new ArrayCollection();
  160.         $this->profSchoolPlanners = new ArrayCollection();
  161.         $this->profTimes = new ArrayCollection();
  162.         $this->lessonProgresses = new ArrayCollection();
  163.     }
  165.     public function getId(): ?int
  166.     {
  167.         return $this->id;
  168.     }
  170.     public function getName(): ?string
  171.     {
  172.         return $this->name;
  173.     }
  175.     public function setName(string $name): static
  176.     {
  177.         $this->name = $name;
  179.         return $this;
  180.     }
  182.     public function getCoef(): ?float
  183.     {
  184.         return $this->coef;
  185.     }
  187.     public function setCoef(float $coef): static
  188.     {
  189.         $this->coef = $coef;
  191.         return $this;
  192.     }
  194.     public function getHoraire(): ?float
  195.     {
  196.         return $this->horaire;
  197.     }
  199.     public function setHoraire(?float $horaire): static
  200.     {
  201.         $this->horaire = $horaire;
  203.         return $this;
  204.     }
  206.     public function getClasse(): ?TheClass
  207.     {
  208.         return $this->classe;
  209.     }
  211.     public function setClasse(?TheClass $classe): static
  212.     {
  213.         $this->classe = $classe;
  215.         return $this;
  216.     }
  218.     public function getProf(): ?User
  219.     {
  220.         return $this->prof;
  221.     }
  223.     public function setProf(?User $prof): static
  224.     {
  225.         $this->prof = $prof;
  227.         return $this;
  228.     }
  230.     public function isActive(): ?bool
  231.     {
  232.         return $this->active;
  233.     }
  235.     public function setActive(bool $active): static
  236.     {
  237.         $this->active = $active;
  239.         return $this;
  240.     }
  242.     /**
  243.      * @return Collection<int, HomeWork>
  244.      */
  245.     public function getHomeWorks(): Collection
  246.     {
  247.         return $this->homeWorks;
  248.     }
  250.     public function addHomeWork(HomeWork $homeWork): static
  251.     {
  252.         if (!$this->homeWorks->contains($homeWork)) {
  253.             $this->homeWorks->add($homeWork);
  254.             $homeWork->setSubject($this);
  255.         }
  257.         return $this;
  258.     }
  260.     public function removeHomeWork(HomeWork $homeWork): static
  261.     {
  262.         if ($this->homeWorks->removeElement($homeWork)) {
  263.             // set the owning side to null (unless already changed)
  264.             if ($homeWork->getSubject() === $this) {
  265.                 $homeWork->setSubject(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     /**
  273.      * @return Collection<int, Absence>
  274.      */
  275.     public function getAbsences(): Collection
  276.     {
  277.         return $this->absences;
  278.     }
  280.     public function addAbsence(Absence $absence): static
  281.     {
  282.         if (!$this->absences->contains($absence)) {
  283.             $this->absences->add($absence);
  284.             $absence->setSubject($this);
  285.         }
  287.         return $this;
  288.     }
  290.     public function removeAbsence(Absence $absence): static
  291.     {
  292.         if ($this->absences->removeElement($absence)) {
  293.             // set the owning side to null (unless already changed)
  294.             if ($absence->getSubject() === $this) {
  295.                 $absence->setSubject(null);
  296.             }
  297.         }
  299.         return $this;
  300.     }
  302.     /**
  303.      * @return Collection<int, LessonLog>
  304.      */
  305.     public function getLessonLogs(): Collection
  306.     {
  307.         return $this->lessonLogs;
  308.     }
  310.     public function addLessonLog(LessonLog $lessonLog): static
  311.     {
  312.         if (!$this->lessonLogs->contains($lessonLog)) {
  313.             $this->lessonLogs->add($lessonLog);
  314.             $lessonLog->setSubject($this);
  315.         }
  317.         return $this;
  318.     }
  320.     public function removeLessonLog(LessonLog $lessonLog): static
  321.     {
  322.         if ($this->lessonLogs->removeElement($lessonLog)) {
  323.             if ($lessonLog->getSubject() === $this) {
  324.                 $lessonLog->setSubject(null);
  325.             }
  326.         }
  328.         return $this;
  329.     }
  331.     public function getSubjectGroup(): ?SubjectGroup
  332.     {
  333.         return $this->subjectGroup;
  334.     }
  336.     public function setSubjectGroup(?SubjectGroup $subjectGroup): static
  337.     {
  338.         $this->subjectGroup = $subjectGroup;
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Note>
  345.      */
  346.     public function getNotes(): Collection
  347.     {
  348.         return $this->notes;
  349.     }
  351.     public function addNote(Note $note): static
  352.     {
  353.         if (!$this->notes->contains($note)) {
  354.             $this->notes->add($note);
  355.             $note->setSubject($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeNote(Note $note): static
  362.     {
  363.         if ($this->notes->removeElement($note)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($note->getSubject() === $this) {
  366.                 $note->setSubject(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     /**
  374.      * @return Collection<int, Exams>
  375.      */
  376.     public function getExams(): Collection
  377.     {
  378.         return $this->exams;
  379.     }
  381.     public function addExam(Exams $exam): static
  382.     {
  383.         if (!$this->exams->contains($exam)) {
  384.             $this->exams->add($exam);
  385.             $exam->setSubject($this);
  386.         }
  388.         return $this;
  389.     }
  391.     public function removeExam(Exams $exam): static
  392.     {
  393.         if ($this->exams->removeElement($exam)) {
  394.             // set the owning side to null (unless already changed)
  395.             if ($exam->getSubject() === $this) {
  396.                 $exam->setSubject(null);
  397.             }
  398.         }
  400.         return $this;
  401.     }
  403.     public function getEditor(): ?User
  404.     {
  405.         return $this->editor;
  406.     }
  408.     public function setEditor(?User $editor): static
  409.     {
  410.         $this->editor = $editor;
  412.         return $this;
  413.     }
  415.     public function getAuthor(): ?User
  416.     {
  417.         return $this->author;
  418.     }
  420.     public function setAuthor(?User $author): static
  421.     {
  422.         $this->author = $author;
  424.         return $this;
  425.     }
  427.     public function getSchool(): ?School
  428.     {
  429.         return $this->school;
  430.     }
  432.     public function setSchool(?School $school): static
  433.     {
  434.         $this->school = $school;
  436.         return $this;
  437.     }
  439.     /**
  440.      * @return Collection<int, AgendaElement>
  441.      */
  442.     public function getAgendaElements(): Collection
  443.     {
  444.         return $this->agendaElements;
  445.     }
  447.     public function addAgendaElement(AgendaElement $agendaElement): static
  448.     {
  449.         if (!$this->agendaElements->contains($agendaElement)) {
  450.             $this->agendaElements->add($agendaElement);
  451.             $agendaElement->setSubject($this);
  452.         }
  454.         return $this;
  455.     }
  457.     public function removeAgendaElement(AgendaElement $agendaElement): static
  458.     {
  459.         if ($this->agendaElements->removeElement($agendaElement)) {
  460.             // set the owning side to null (unless already changed)
  461.             if ($agendaElement->getSubject() === $this) {
  462.                 $agendaElement->setSubject(null);
  463.             }
  464.         }
  466.         return $this;
  467.     }
  469.     /**
  470.      * @return Collection<int, ExamAgendaElement>
  471.      */
  472.     public function getExamAgendaElements(): Collection
  473.     {
  474.         return $this->examAgendaElements;
  475.     }
  477.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  478.     {
  479.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  480.             $this->examAgendaElements->add($examAgendaElement);
  481.             $examAgendaElement->setSubject($this);
  482.         }
  484.         return $this;
  485.     }
  487.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  488.     {
  489.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  490.             // set the owning side to null (unless already changed)
  491.             if ($examAgendaElement->getSubject() === $this) {
  492.                 $examAgendaElement->setSubject(null);
  493.             }
  494.         }
  496.         return $this;
  497.     }
  499.     public function getCompetence(): ?string
  500.     {
  501.         return $this->competence;
  502.     }
  504.     public function setCompetence(?string $competence): static
  505.     {
  506.         $this->competence = $competence;
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection<int, ParentNote>
  513.      */
  514.     public function getParentNotes(): Collection
  515.     {
  516.         return $this->parentNotes;
  517.     }
  519.     public function addParentNote(ParentNote $parentNote): static
  520.     {
  521.         if (!$this->parentNotes->contains($parentNote)) {
  522.             $this->parentNotes->add($parentNote);
  523.             $parentNote->setSubject($this);
  524.         }
  525.         return $this;
  526.     }
  528.     /* 
  529.         @return Collection<int, SubNote>
  530.      */
  531.     public function getSubNotes(): Collection
  532.     {
  533.         return $this->subNotes;
  534.     }
  536.     public function addSubNote(SubNote $subNote): static
  537.     {
  538.         if (!$this->subNotes->contains($subNote)) {
  539.             $this->subNotes->add($subNote);
  540.             $subNote->setSubject($this);
  541.         }
  543.         return $this;
  544.     }
  546.     public function removeParentNote(ParentNote $parentNote): static
  547.     {
  548.         if ($this->parentNotes->removeElement($parentNote)) {
  549.             // set the owning side to null (unless already changed)
  550.             if ($parentNote->getSubject() === $this) {
  551.                 $parentNote->setSubject(null);
  552.             }
  553.         }
  554.         return $this;
  555.     }
  556.     public function removeSubNote(SubNote $subNote): static
  557.     {
  558.         if ($this->subNotes->removeElement($subNote)) {
  559.             // set the owning side to null (unless already changed)
  560.             if ($subNote->getSubject() === $this) {
  561.                 $subNote->setSubject(null);
  562.             }
  563.         }
  565.         return $this;
  566.     }
  568.     public function getYear(): ?SchoolYear
  569.     {
  570.         return $this->year;
  571.     }
  573.     public function setYear(?SchoolYear $year): static
  574.     {
  575.         $this->year = $year;
  577.         return $this;
  578.     }
  580.     public function getPrimaryParentNote(): ?PrimaryParentNote
  581.     {
  582.         return $this->primaryParentNote;
  583.     }
  585.     public function setPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  586.     {
  587.         // set the owning side of the relation if necessary
  588.         if ($primaryParentNote->getSubject() !== $this) {
  589.             $primaryParentNote->setSubject($this);
  590.         }
  592.         $this->primaryParentNote = $primaryParentNote;
  594.         return $this;
  595.     }
  597.     /**
  598.      * @return Collection<int, PrimaryNote>
  599.      */
  600.     public function getPrimaryNotes(): Collection
  601.     {
  602.         return $this->primaryNotes;
  603.     }
  605.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  606.     {
  607.         if (!$this->primaryNotes->contains($primaryNote)) {
  608.             $this->primaryNotes->add($primaryNote);
  609.             $primaryNote->setSubject($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  616.     {
  617.         if ($this->primaryNotes->removeElement($primaryNote)) {
  618.             // set the owning side to null (unless already changed)
  619.             if ($primaryNote->getSubject() === $this) {
  620.                 $primaryNote->setSubject(null);
  621.             }
  622.         }
  624.         return $this;
  625.     }
  627.     public function getPoint(): ?float
  628.     {
  629.         return $this->point;
  630.     }
  632.     public function setPoint(?float $point): static
  633.     {
  634.         $this->point = $point;
  636.         return $this;
  637.     }
  639.     public function getTotalPoints(): ?float
  640.     {
  641.         return $this->totalPoints;
  642.     }
  644.     public function setTotalPoints(?float $totalPoints): static
  645.     {
  646.         $this->totalPoints = $totalPoints;
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection<int, Competence>
  653.      */
  654.     public function getCompetences(): Collection
  655.     {
  656.         return $this->competences;
  657.     }
  659.     public function addCompetence(Competence $competence): static
  660.     {
  661.         if (!$this->competences->contains($competence)) {
  662.             $this->competences->add($competence);
  663.             $competence->setSubject($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removeCompetence(Competence $competence): static
  670.     {
  671.         if ($this->competences->removeElement($competence)) {
  672.             // set the owning side to null (unless already changed)
  673.             if ($competence->getSubject() === $this) {
  674.                 $competence->setSubject(null);
  675.             }
  676.         }
  678.         return $this;
  679.     }
  681.     /**
  682.      * @return Collection<int, WeekSubjectGoal>
  683.      */
  684.     public function getWeekSubjectGoals(): Collection
  685.     {
  686.         return $this->weekSubjectGoals;
  687.     }
  689.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  690.     {
  691.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  692.             $this->weekSubjectGoals->add($weekSubjectGoal);
  693.             $weekSubjectGoal->setSubject($this);
  694.         }
  696.         return $this;
  697.     }
  699.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  700.     {
  701.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  702.             // set the owning side to null (unless already changed)
  703.             if ($weekSubjectGoal->getSubject() === $this) {
  704.                 $weekSubjectGoal->setSubject(null);
  705.             }
  706.         }
  708.         return $this;
  709.     }
  711.     /**
  712.      * @return Collection<int, ProfSchoolPlanner>
  713.      */
  714.     public function getProfSchoolPlanners(): Collection
  715.     {
  716.         return $this->profSchoolPlanners;
  717.     }
  719.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  720.     {
  721.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  722.             $this->profSchoolPlanners->add($profSchoolPlanner);
  723.             $profSchoolPlanner->setSubject($this);
  724.         }
  726.         return $this;
  727.     }
  729.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  730.     {
  731.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  732.             // set the owning side to null (unless already changed)
  733.             if ($profSchoolPlanner->getSubject() === $this) {
  734.                 $profSchoolPlanner->setSubject(null);
  735.             }
  736.         }
  738.         return $this;
  739.     }
  741.     public function getLongitude(): ?float
  742.     {
  743.         return $this->longitude;
  744.     }
  746.     public function setLongitude(?float $longitude): static
  747.     {
  748.         $this->longitude = $longitude;
  750.         return $this;
  751.     }
  753.     public function getLatitude(): ?float
  754.     {
  755.         return $this->latitude;
  756.     }
  758.     public function setLatitude(?float $latitude): static
  759.     {
  760.         $this->latitude = $latitude;
  762.         return $this;
  763.     }
  765.     /**
  766.      * @return Collection<int, ProfTime>
  767.      */
  768.     public function getProfTimes(): Collection
  769.     {
  770.         return $this->profTimes;
  771.     }
  773.     public function addProfTime(ProfTime $profTime): static
  774.     {
  775.         if (!$this->profTimes->contains($profTime)) {
  776.             $this->profTimes->add($profTime);
  777.             $profTime->setSubject($this);
  778.         }
  780.         return $this;
  781.     }
  783.     public function removeProfTime(ProfTime $profTime): static
  784.     {
  785.         if ($this->profTimes->removeElement($profTime)) {
  786.             // set the owning side to null (unless already changed)
  787.             if ($profTime->getSubject() === $this) {
  788.                 $profTime->setSubject(null);
  789.             }
  790.         }
  792.         return $this;
  793.     }
  795.     /**
  796.      * @return Collection<int, LessonProgress>
  797.      */
  798.     public function getLessonProgresses(): Collection
  799.     {
  800.         return $this->lessonProgresses;
  801.     }
  803.     public function addLessonProgress(LessonProgress $lessonProgress): static
  804.     {
  805.         if (!$this->lessonProgresses->contains($lessonProgress)) {
  806.             $this->lessonProgresses->add($lessonProgress);
  807.             $lessonProgress->setSubject($this);
  808.         }
  810.         return $this;
  811.     }
  813.     public function removeLessonProgress(LessonProgress $lessonProgress): static
  814.     {
  815.         if ($this->lessonProgresses->removeElement($lessonProgress)) {
  816.             if ($lessonProgress->getSubject() === $this) {
  817.                 $lessonProgress->setSubject(null);
  818.             }
  819.         }
  821.         return $this;
  822.     }
  824.     public function getReference(): ?SubjectReference
  825.     {
  826.         return $this->reference;
  827.     }
  829.     public function setReference(?SubjectReference $reference): static
  830.     {
  831.         $this->reference = $reference;
  833.         return $this;
  834.     }
  835. }