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.     #[ORM\ManyToOne(inversedBy: 'subjects', cascade: ["persist"])]
  49.     #[ORM\JoinColumn(nullable: false)]
  50.     private ?SubjectGroup $subjectGroup = null;
  52.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Note::class)]
  53.     private Collection $notes;
  55.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Exams::class)]
  56.     private Collection $exams;
  58.     #[ORM\ManyToOne(inversedBy: 'subjectsEdited', cascade: ["persist"])]
  59.     private ?User $editor = null;
  61.     #[ORM\ManyToOne(inversedBy: 'subjectsCreated', cascade: ["persist"])]
  62.     private ?User $author = null;
  64.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'subjects')]
  65.     #[Groups(['getSubject'])]
  66.     private ?School $school = null;
  68.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: AgendaElement::class)]
  69.     private Collection $agendaElements;
  71.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ExamAgendaElement::class)]
  72.     private Collection $examAgendaElements;
  74.     #[Groups(['getAbsence','homework','note','getBulletin','getDiscussion', 'getAgenda', 'getExamAgenda'])]
  75.     #[ORM\Column(length: 255, nullable: true)]
  76.     private ?string $competence = null;
  78.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ParentNote::class)]
  79.     private Collection $parentNotes;
  81.     #[ORM\ManyToOne(inversedBy: 'subjects')]
  82.     private ?SchoolYear $year = null;
  84.     #[ORM\OneToOne(mappedBy: 'subject', cascade: ['persist', 'remove'])]
  85.     private ?PrimaryParentNote $primaryParentNote = null;
  87.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: PrimaryNote::class)]
  88.     private Collection $primaryNotes;
  90.     #[ORM\Column(nullable: true)]
  91.     private ?float $point = null;
  93.     #[ORM\Column(nullable: true)]
  94.     private ?float $totalPoints = null;
  95.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: SubNote::class, orphanRemoval: true)]
  96.     private Collection $subNotes;
  98.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: Competence::class, cascade: ["persist", "remove"], orphanRemoval: true)]
  99.     private Collection $competences;
  101.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: WeekSubjectGoal::class)]
  102.     private Collection $weekSubjectGoals;
  104.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfSchoolPlanner::class)]
  105.     private Collection $profSchoolPlanners;
  107.     #[ORM\Column(nullable: true)]
  108.     private ?float $longitude = null;
  110.     #[ORM\Column(nullable: true)]
  111.     private ?float $latitude = null;
  113.     #[ORM\OneToMany(mappedBy: 'subject', targetEntity: ProfTime::class)]
  114.     private Collection $profTimes;
  116.     public function __toString():string
  117.     {
  118.         return $this->name;
  119.     }
  121.     public function __construct()
  122.     {
  123.         $this->homeWorks = new ArrayCollection();
  124.         $this->absences = new ArrayCollection();
  125.         $this->notes = new ArrayCollection();
  126.         $this->exams = new ArrayCollection();
  127.         $this->agendaElements = new ArrayCollection();
  128.         $this->examAgendaElements = new ArrayCollection();
  129.         $this->parentNotes = new ArrayCollection();
  130.         $this->primaryNotes = new ArrayCollection();
  131.         $this->subNotes = new ArrayCollection();
  132.         $this->competences = new ArrayCollection();
  133.         $this->weekSubjectGoals = new ArrayCollection();
  134.         $this->profSchoolPlanners = new ArrayCollection();
  135.         $this->profTimes = new ArrayCollection();
  136.     }
  138.     public function getId(): ?int
  139.     {
  140.         return $this->id;
  141.     }
  143.     public function getName(): ?string
  144.     {
  145.         return $this->name;
  146.     }
  148.     public function setName(string $name): static
  149.     {
  150.         $this->name = $name;
  152.         return $this;
  153.     }
  155.     public function getCoef(): ?float
  156.     {
  157.         return $this->coef;
  158.     }
  160.     public function setCoef(float $coef): static
  161.     {
  162.         $this->coef = $coef;
  164.         return $this;
  165.     }
  167.     public function getClasse(): ?TheClass
  168.     {
  169.         return $this->classe;
  170.     }
  172.     public function setClasse(?TheClass $classe): static
  173.     {
  174.         $this->classe = $classe;
  176.         return $this;
  177.     }
  179.     public function getProf(): ?User
  180.     {
  181.         return $this->prof;
  182.     }
  184.     public function setProf(?User $prof): static
  185.     {
  186.         $this->prof = $prof;
  188.         return $this;
  189.     }
  191.     public function isActive(): ?bool
  192.     {
  193.         return $this->active;
  194.     }
  196.     public function setActive(bool $active): static
  197.     {
  198.         $this->active = $active;
  200.         return $this;
  201.     }
  203.     /**
  204.      * @return Collection<int, HomeWork>
  205.      */
  206.     public function getHomeWorks(): Collection
  207.     {
  208.         return $this->homeWorks;
  209.     }
  211.     public function addHomeWork(HomeWork $homeWork): static
  212.     {
  213.         if (!$this->homeWorks->contains($homeWork)) {
  214.             $this->homeWorks->add($homeWork);
  215.             $homeWork->setSubject($this);
  216.         }
  218.         return $this;
  219.     }
  221.     public function removeHomeWork(HomeWork $homeWork): static
  222.     {
  223.         if ($this->homeWorks->removeElement($homeWork)) {
  224.             // set the owning side to null (unless already changed)
  225.             if ($homeWork->getSubject() === $this) {
  226.                 $homeWork->setSubject(null);
  227.             }
  228.         }
  230.         return $this;
  231.     }
  233.     /**
  234.      * @return Collection<int, Absence>
  235.      */
  236.     public function getAbsences(): Collection
  237.     {
  238.         return $this->absences;
  239.     }
  241.     public function addAbsence(Absence $absence): static
  242.     {
  243.         if (!$this->absences->contains($absence)) {
  244.             $this->absences->add($absence);
  245.             $absence->setSubject($this);
  246.         }
  248.         return $this;
  249.     }
  251.     public function removeAbsence(Absence $absence): static
  252.     {
  253.         if ($this->absences->removeElement($absence)) {
  254.             // set the owning side to null (unless already changed)
  255.             if ($absence->getSubject() === $this) {
  256.                 $absence->setSubject(null);
  257.             }
  258.         }
  260.         return $this;
  261.     }
  263.     public function getSubjectGroup(): ?SubjectGroup
  264.     {
  265.         return $this->subjectGroup;
  266.     }
  268.     public function setSubjectGroup(?SubjectGroup $subjectGroup): static
  269.     {
  270.         $this->subjectGroup = $subjectGroup;
  272.         return $this;
  273.     }
  275.     /**
  276.      * @return Collection<int, Note>
  277.      */
  278.     public function getNotes(): Collection
  279.     {
  280.         return $this->notes;
  281.     }
  283.     public function addNote(Note $note): static
  284.     {
  285.         if (!$this->notes->contains($note)) {
  286.             $this->notes->add($note);
  287.             $note->setSubject($this);
  288.         }
  290.         return $this;
  291.     }
  293.     public function removeNote(Note $note): static
  294.     {
  295.         if ($this->notes->removeElement($note)) {
  296.             // set the owning side to null (unless already changed)
  297.             if ($note->getSubject() === $this) {
  298.                 $note->setSubject(null);
  299.             }
  300.         }
  302.         return $this;
  303.     }
  305.     /**
  306.      * @return Collection<int, Exams>
  307.      */
  308.     public function getExams(): Collection
  309.     {
  310.         return $this->exams;
  311.     }
  313.     public function addExam(Exams $exam): static
  314.     {
  315.         if (!$this->exams->contains($exam)) {
  316.             $this->exams->add($exam);
  317.             $exam->setSubject($this);
  318.         }
  320.         return $this;
  321.     }
  323.     public function removeExam(Exams $exam): static
  324.     {
  325.         if ($this->exams->removeElement($exam)) {
  326.             // set the owning side to null (unless already changed)
  327.             if ($exam->getSubject() === $this) {
  328.                 $exam->setSubject(null);
  329.             }
  330.         }
  332.         return $this;
  333.     }
  335.     public function getEditor(): ?User
  336.     {
  337.         return $this->editor;
  338.     }
  340.     public function setEditor(?User $editor): static
  341.     {
  342.         $this->editor = $editor;
  344.         return $this;
  345.     }
  347.     public function getAuthor(): ?User
  348.     {
  349.         return $this->author;
  350.     }
  352.     public function setAuthor(?User $author): static
  353.     {
  354.         $this->author = $author;
  356.         return $this;
  357.     }
  359.     public function getSchool(): ?School
  360.     {
  361.         return $this->school;
  362.     }
  364.     public function setSchool(?School $school): static
  365.     {
  366.         $this->school = $school;
  368.         return $this;
  369.     }
  371.     /**
  372.      * @return Collection<int, AgendaElement>
  373.      */
  374.     public function getAgendaElements(): Collection
  375.     {
  376.         return $this->agendaElements;
  377.     }
  379.     public function addAgendaElement(AgendaElement $agendaElement): static
  380.     {
  381.         if (!$this->agendaElements->contains($agendaElement)) {
  382.             $this->agendaElements->add($agendaElement);
  383.             $agendaElement->setSubject($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeAgendaElement(AgendaElement $agendaElement): static
  390.     {
  391.         if ($this->agendaElements->removeElement($agendaElement)) {
  392.             // set the owning side to null (unless already changed)
  393.             if ($agendaElement->getSubject() === $this) {
  394.                 $agendaElement->setSubject(null);
  395.             }
  396.         }
  398.         return $this;
  399.     }
  401.     /**
  402.      * @return Collection<int, ExamAgendaElement>
  403.      */
  404.     public function getExamAgendaElements(): Collection
  405.     {
  406.         return $this->examAgendaElements;
  407.     }
  409.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  410.     {
  411.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  412.             $this->examAgendaElements->add($examAgendaElement);
  413.             $examAgendaElement->setSubject($this);
  414.         }
  416.         return $this;
  417.     }
  419.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  420.     {
  421.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  422.             // set the owning side to null (unless already changed)
  423.             if ($examAgendaElement->getSubject() === $this) {
  424.                 $examAgendaElement->setSubject(null);
  425.             }
  426.         }
  428.         return $this;
  429.     }
  431.     public function getCompetence(): ?string
  432.     {
  433.         return $this->competence;
  434.     }
  436.     public function setCompetence(?string $competence): static
  437.     {
  438.         $this->competence = $competence;
  440.         return $this;
  441.     }
  443.     /**
  444.      * @return Collection<int, ParentNote>
  445.      */
  446.     public function getParentNotes(): Collection
  447.     {
  448.         return $this->parentNotes;
  449.     }
  451.     public function addParentNote(ParentNote $parentNote): static
  452.     {
  453.         if (!$this->parentNotes->contains($parentNote)) {
  454.             $this->parentNotes->add($parentNote);
  455.             $parentNote->setSubject($this);
  456.         }
  457.         return $this;
  458.     }
  460.     /* 
  461.         @return Collection<int, SubNote>
  462.      */
  463.     public function getSubNotes(): Collection
  464.     {
  465.         return $this->subNotes;
  466.     }
  468.     public function addSubNote(SubNote $subNote): static
  469.     {
  470.         if (!$this->subNotes->contains($subNote)) {
  471.             $this->subNotes->add($subNote);
  472.             $subNote->setSubject($this);
  473.         }
  475.         return $this;
  476.     }
  478.     public function removeParentNote(ParentNote $parentNote): static
  479.     {
  480.         if ($this->parentNotes->removeElement($parentNote)) {
  481.             // set the owning side to null (unless already changed)
  482.             if ($parentNote->getSubject() === $this) {
  483.                 $parentNote->setSubject(null);
  484.             }
  485.         }
  486.         return $this;
  487.     }
  488.     public function removeSubNote(SubNote $subNote): static
  489.     {
  490.         if ($this->subNotes->removeElement($subNote)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($subNote->getSubject() === $this) {
  493.                 $subNote->setSubject(null);
  494.             }
  495.         }
  497.         return $this;
  498.     }
  500.     public function getYear(): ?SchoolYear
  501.     {
  502.         return $this->year;
  503.     }
  505.     public function setYear(?SchoolYear $year): static
  506.     {
  507.         $this->year = $year;
  509.         return $this;
  510.     }
  512.     public function getPrimaryParentNote(): ?PrimaryParentNote
  513.     {
  514.         return $this->primaryParentNote;
  515.     }
  517.     public function setPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  518.     {
  519.         // set the owning side of the relation if necessary
  520.         if ($primaryParentNote->getSubject() !== $this) {
  521.             $primaryParentNote->setSubject($this);
  522.         }
  524.         $this->primaryParentNote = $primaryParentNote;
  526.         return $this;
  527.     }
  529.     /**
  530.      * @return Collection<int, PrimaryNote>
  531.      */
  532.     public function getPrimaryNotes(): Collection
  533.     {
  534.         return $this->primaryNotes;
  535.     }
  537.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  538.     {
  539.         if (!$this->primaryNotes->contains($primaryNote)) {
  540.             $this->primaryNotes->add($primaryNote);
  541.             $primaryNote->setSubject($this);
  542.         }
  544.         return $this;
  545.     }
  547.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  548.     {
  549.         if ($this->primaryNotes->removeElement($primaryNote)) {
  550.             // set the owning side to null (unless already changed)
  551.             if ($primaryNote->getSubject() === $this) {
  552.                 $primaryNote->setSubject(null);
  553.             }
  554.         }
  556.         return $this;
  557.     }
  559.     public function getPoint(): ?float
  560.     {
  561.         return $this->point;
  562.     }
  564.     public function setPoint(?float $point): static
  565.     {
  566.         $this->point = $point;
  568.         return $this;
  569.     }
  571.     public function getTotalPoints(): ?float
  572.     {
  573.         return $this->totalPoints;
  574.     }
  576.     public function setTotalPoints(?float $totalPoints): static
  577.     {
  578.         $this->totalPoints = $totalPoints;
  580.         return $this;
  581.     }
  583.     /**
  584.      * @return Collection<int, Competence>
  585.      */
  586.     public function getCompetences(): Collection
  587.     {
  588.         return $this->competences;
  589.     }
  591.     public function addCompetence(Competence $competence): static
  592.     {
  593.         if (!$this->competences->contains($competence)) {
  594.             $this->competences->add($competence);
  595.             $competence->setSubject($this);
  596.         }
  598.         return $this;
  599.     }
  601.     public function removeCompetence(Competence $competence): static
  602.     {
  603.         if ($this->competences->removeElement($competence)) {
  604.             // set the owning side to null (unless already changed)
  605.             if ($competence->getSubject() === $this) {
  606.                 $competence->setSubject(null);
  607.             }
  608.         }
  610.         return $this;
  611.     }
  613.     /**
  614.      * @return Collection<int, WeekSubjectGoal>
  615.      */
  616.     public function getWeekSubjectGoals(): Collection
  617.     {
  618.         return $this->weekSubjectGoals;
  619.     }
  621.     public function addWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  622.     {
  623.         if (!$this->weekSubjectGoals->contains($weekSubjectGoal)) {
  624.             $this->weekSubjectGoals->add($weekSubjectGoal);
  625.             $weekSubjectGoal->setSubject($this);
  626.         }
  628.         return $this;
  629.     }
  631.     public function removeWeekSubjectGoal(WeekSubjectGoal $weekSubjectGoal): static
  632.     {
  633.         if ($this->weekSubjectGoals->removeElement($weekSubjectGoal)) {
  634.             // set the owning side to null (unless already changed)
  635.             if ($weekSubjectGoal->getSubject() === $this) {
  636.                 $weekSubjectGoal->setSubject(null);
  637.             }
  638.         }
  640.         return $this;
  641.     }
  643.     /**
  644.      * @return Collection<int, ProfSchoolPlanner>
  645.      */
  646.     public function getProfSchoolPlanners(): Collection
  647.     {
  648.         return $this->profSchoolPlanners;
  649.     }
  651.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  652.     {
  653.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  654.             $this->profSchoolPlanners->add($profSchoolPlanner);
  655.             $profSchoolPlanner->setSubject($this);
  656.         }
  658.         return $this;
  659.     }
  661.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  662.     {
  663.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  664.             // set the owning side to null (unless already changed)
  665.             if ($profSchoolPlanner->getSubject() === $this) {
  666.                 $profSchoolPlanner->setSubject(null);
  667.             }
  668.         }
  670.         return $this;
  671.     }
  673.     public function getLongitude(): ?float
  674.     {
  675.         return $this->longitude;
  676.     }
  678.     public function setLongitude(?float $longitude): static
  679.     {
  680.         $this->longitude = $longitude;
  682.         return $this;
  683.     }
  685.     public function getLatitude(): ?float
  686.     {
  687.         return $this->latitude;
  688.     }
  690.     public function setLatitude(?float $latitude): static
  691.     {
  692.         $this->latitude = $latitude;
  694.         return $this;
  695.     }
  697.     /**
  698.      * @return Collection<int, ProfTime>
  699.      */
  700.     public function getProfTimes(): Collection
  701.     {
  702.         return $this->profTimes;
  703.     }
  705.     public function addProfTime(ProfTime $profTime): static
  706.     {
  707.         if (!$this->profTimes->contains($profTime)) {
  708.             $this->profTimes->add($profTime);
  709.             $profTime->setSubject($this);
  710.         }
  712.         return $this;
  713.     }
  715.     public function removeProfTime(ProfTime $profTime): static
  716.     {
  717.         if ($this->profTimes->removeElement($profTime)) {
  718.             // set the owning side to null (unless already changed)
  719.             if ($profTime->getSubject() === $this) {
  720.                 $profTime->setSubject(null);
  721.             }
  722.         }
  724.         return $this;
  725.     }
  726. }