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: TimeTable::class)]
  99.     private Collection $timeTables;
  101.     public function __toString():string
  102.     {
  103.         return $this->name;
  104.     }
  106.     public function __construct()
  107.     {
  108.         $this->homeWorks = new ArrayCollection();
  109.         $this->absences = new ArrayCollection();
  110.         $this->notes = new ArrayCollection();
  111.         $this->exams = new ArrayCollection();
  112.         $this->agendaElements = new ArrayCollection();
  113.         $this->examAgendaElements = new ArrayCollection();
  114.         $this->parentNotes = new ArrayCollection();
  115.         $this->primaryNotes = new ArrayCollection();
  116.         $this->subNotes = new ArrayCollection();
  117.         $this->timeTables = new ArrayCollection();
  118.     }
  120.     public function getId(): ?int
  121.     {
  122.         return $this->id;
  123.     }
  125.     public function getName(): ?string
  126.     {
  127.         return $this->name;
  128.     }
  130.     public function setName(string $name): static
  131.     {
  132.         $this->name = $name;
  134.         return $this;
  135.     }
  137.     public function getCoef(): ?float
  138.     {
  139.         return $this->coef;
  140.     }
  142.     public function setCoef(float $coef): static
  143.     {
  144.         $this->coef = $coef;
  146.         return $this;
  147.     }
  149.     public function getClasse(): ?TheClass
  150.     {
  151.         return $this->classe;
  152.     }
  154.     public function setClasse(?TheClass $classe): static
  155.     {
  156.         $this->classe = $classe;
  158.         return $this;
  159.     }
  161.     public function getProf(): ?User
  162.     {
  163.         return $this->prof;
  164.     }
  166.     public function setProf(?User $prof): static
  167.     {
  168.         $this->prof = $prof;
  170.         return $this;
  171.     }
  173.     public function isActive(): ?bool
  174.     {
  175.         return $this->active;
  176.     }
  178.     public function setActive(bool $active): static
  179.     {
  180.         $this->active = $active;
  182.         return $this;
  183.     }
  185.     /**
  186.      * @return Collection<int, HomeWork>
  187.      */
  188.     public function getHomeWorks(): Collection
  189.     {
  190.         return $this->homeWorks;
  191.     }
  193.     public function addHomeWork(HomeWork $homeWork): static
  194.     {
  195.         if (!$this->homeWorks->contains($homeWork)) {
  196.             $this->homeWorks->add($homeWork);
  197.             $homeWork->setSubject($this);
  198.         }
  200.         return $this;
  201.     }
  203.     public function removeHomeWork(HomeWork $homeWork): static
  204.     {
  205.         if ($this->homeWorks->removeElement($homeWork)) {
  206.             // set the owning side to null (unless already changed)
  207.             if ($homeWork->getSubject() === $this) {
  208.                 $homeWork->setSubject(null);
  209.             }
  210.         }
  212.         return $this;
  213.     }
  215.     /**
  216.      * @return Collection<int, Absence>
  217.      */
  218.     public function getAbsences(): Collection
  219.     {
  220.         return $this->absences;
  221.     }
  223.     public function addAbsence(Absence $absence): static
  224.     {
  225.         if (!$this->absences->contains($absence)) {
  226.             $this->absences->add($absence);
  227.             $absence->setSubject($this);
  228.         }
  230.         return $this;
  231.     }
  233.     public function removeAbsence(Absence $absence): static
  234.     {
  235.         if ($this->absences->removeElement($absence)) {
  236.             // set the owning side to null (unless already changed)
  237.             if ($absence->getSubject() === $this) {
  238.                 $absence->setSubject(null);
  239.             }
  240.         }
  242.         return $this;
  243.     }
  245.     public function getSubjectGroup(): ?SubjectGroup
  246.     {
  247.         return $this->subjectGroup;
  248.     }
  250.     public function setSubjectGroup(?SubjectGroup $subjectGroup): static
  251.     {
  252.         $this->subjectGroup = $subjectGroup;
  254.         return $this;
  255.     }
  257.     /**
  258.      * @return Collection<int, Note>
  259.      */
  260.     public function getNotes(): Collection
  261.     {
  262.         return $this->notes;
  263.     }
  265.     public function addNote(Note $note): static
  266.     {
  267.         if (!$this->notes->contains($note)) {
  268.             $this->notes->add($note);
  269.             $note->setSubject($this);
  270.         }
  272.         return $this;
  273.     }
  275.     public function removeNote(Note $note): static
  276.     {
  277.         if ($this->notes->removeElement($note)) {
  278.             // set the owning side to null (unless already changed)
  279.             if ($note->getSubject() === $this) {
  280.                 $note->setSubject(null);
  281.             }
  282.         }
  284.         return $this;
  285.     }
  287.     /**
  288.      * @return Collection<int, Exams>
  289.      */
  290.     public function getExams(): Collection
  291.     {
  292.         return $this->exams;
  293.     }
  295.     public function addExam(Exams $exam): static
  296.     {
  297.         if (!$this->exams->contains($exam)) {
  298.             $this->exams->add($exam);
  299.             $exam->setSubject($this);
  300.         }
  302.         return $this;
  303.     }
  305.     public function removeExam(Exams $exam): static
  306.     {
  307.         if ($this->exams->removeElement($exam)) {
  308.             // set the owning side to null (unless already changed)
  309.             if ($exam->getSubject() === $this) {
  310.                 $exam->setSubject(null);
  311.             }
  312.         }
  314.         return $this;
  315.     }
  317.     public function getEditor(): ?User
  318.     {
  319.         return $this->editor;
  320.     }
  322.     public function setEditor(?User $editor): static
  323.     {
  324.         $this->editor = $editor;
  326.         return $this;
  327.     }
  329.     public function getAuthor(): ?User
  330.     {
  331.         return $this->author;
  332.     }
  334.     public function setAuthor(?User $author): static
  335.     {
  336.         $this->author = $author;
  338.         return $this;
  339.     }
  341.     public function getSchool(): ?School
  342.     {
  343.         return $this->school;
  344.     }
  346.     public function setSchool(?School $school): static
  347.     {
  348.         $this->school = $school;
  350.         return $this;
  351.     }
  353.     /**
  354.      * @return Collection<int, AgendaElement>
  355.      */
  356.     public function getAgendaElements(): Collection
  357.     {
  358.         return $this->agendaElements;
  359.     }
  361.     public function addAgendaElement(AgendaElement $agendaElement): static
  362.     {
  363.         if (!$this->agendaElements->contains($agendaElement)) {
  364.             $this->agendaElements->add($agendaElement);
  365.             $agendaElement->setSubject($this);
  366.         }
  368.         return $this;
  369.     }
  371.     public function removeAgendaElement(AgendaElement $agendaElement): static
  372.     {
  373.         if ($this->agendaElements->removeElement($agendaElement)) {
  374.             // set the owning side to null (unless already changed)
  375.             if ($agendaElement->getSubject() === $this) {
  376.                 $agendaElement->setSubject(null);
  377.             }
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.      * @return Collection<int, ExamAgendaElement>
  385.      */
  386.     public function getExamAgendaElements(): Collection
  387.     {
  388.         return $this->examAgendaElements;
  389.     }
  391.     public function addExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  392.     {
  393.         if (!$this->examAgendaElements->contains($examAgendaElement)) {
  394.             $this->examAgendaElements->add($examAgendaElement);
  395.             $examAgendaElement->setSubject($this);
  396.         }
  398.         return $this;
  399.     }
  401.     public function removeExamAgendaElement(ExamAgendaElement $examAgendaElement): static
  402.     {
  403.         if ($this->examAgendaElements->removeElement($examAgendaElement)) {
  404.             // set the owning side to null (unless already changed)
  405.             if ($examAgendaElement->getSubject() === $this) {
  406.                 $examAgendaElement->setSubject(null);
  407.             }
  408.         }
  410.         return $this;
  411.     }
  413.     public function getCompetence(): ?string
  414.     {
  415.         return $this->competence;
  416.     }
  418.     public function setCompetence(?string $competence): static
  419.     {
  420.         $this->competence = $competence;
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, ParentNote>
  427.      */
  428.     public function getParentNotes(): Collection
  429.     {
  430.         return $this->parentNotes;
  431.     }
  433.     public function addParentNote(ParentNote $parentNote): static
  434.     {
  435.         if (!$this->parentNotes->contains($parentNote)) {
  436.             $this->parentNotes->add($parentNote);
  437.             $parentNote->setSubject($this);
  438.         }
  439.         return $this;
  440.     }
  442.     /* 
  443.         @return Collection<int, SubNote>
  444.      */
  445.     public function getSubNotes(): Collection
  446.     {
  447.         return $this->subNotes;
  448.     }
  450.     public function addSubNote(SubNote $subNote): static
  451.     {
  452.         if (!$this->subNotes->contains($subNote)) {
  453.             $this->subNotes->add($subNote);
  454.             $subNote->setSubject($this);
  455.         }
  457.         return $this;
  458.     }
  460.     public function removeParentNote(ParentNote $parentNote): static
  461.     {
  462.         if ($this->parentNotes->removeElement($parentNote)) {
  463.             // set the owning side to null (unless already changed)
  464.             if ($parentNote->getSubject() === $this) {
  465.                 $parentNote->setSubject(null);
  466.             }
  467.         }
  468.         return $this;
  469.     }
  470.     public function removeSubNote(SubNote $subNote): static
  471.     {
  472.         if ($this->subNotes->removeElement($subNote)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($subNote->getSubject() === $this) {
  475.                 $subNote->setSubject(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     public function getYear(): ?SchoolYear
  483.     {
  484.         return $this->year;
  485.     }
  487.     public function setYear(?SchoolYear $year): static
  488.     {
  489.         $this->year = $year;
  491.         return $this;
  492.     }
  494.     public function getPrimaryParentNote(): ?PrimaryParentNote
  495.     {
  496.         return $this->primaryParentNote;
  497.     }
  499.     public function setPrimaryParentNote(PrimaryParentNote $primaryParentNote): static
  500.     {
  501.         // set the owning side of the relation if necessary
  502.         if ($primaryParentNote->getSubject() !== $this) {
  503.             $primaryParentNote->setSubject($this);
  504.         }
  506.         $this->primaryParentNote = $primaryParentNote;
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection<int, PrimaryNote>
  513.      */
  514.     public function getPrimaryNotes(): Collection
  515.     {
  516.         return $this->primaryNotes;
  517.     }
  519.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  520.     {
  521.         if (!$this->primaryNotes->contains($primaryNote)) {
  522.             $this->primaryNotes->add($primaryNote);
  523.             $primaryNote->setSubject($this);
  524.         }
  526.         return $this;
  527.     }
  529.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  530.     {
  531.         if ($this->primaryNotes->removeElement($primaryNote)) {
  532.             // set the owning side to null (unless already changed)
  533.             if ($primaryNote->getSubject() === $this) {
  534.                 $primaryNote->setSubject(null);
  535.             }
  536.         }
  538.         return $this;
  539.     }
  541.     public function getPoint(): ?float
  542.     {
  543.         return $this->point;
  544.     }
  546.     public function setPoint(?float $point): static
  547.     {
  548.         $this->point = $point;
  550.         return $this;
  551.     }
  553.     public function getTotalPoints(): ?float
  554.     {
  555.         return $this->totalPoints;
  556.     }
  558.     public function setTotalPoints(?float $totalPoints): static
  559.     {
  560.         $this->totalPoints = $totalPoints;
  562.         return $this;
  563.     }
  565.     /**
  566.      * @return Collection<int, TimeTable>
  567.      */
  568.     public function getTimeTables(): Collection
  569.     {
  570.         return $this->timeTables;
  571.     }
  573.     public function addTimeTable(TimeTable $timeTable): static
  574.     {
  575.         if (!$this->timeTables->contains($timeTable)) {
  576.             $this->timeTables->add($timeTable);
  577.             $timeTable->setSubject($this);
  578.         }
  580.         return $this;
  581.     }
  583.     public function removeTimeTable(TimeTable $timeTable): static
  584.     {
  585.         if ($this->timeTables->removeElement($timeTable)) {
  586.             // set the owning side to null (unless already changed)
  587.             if ($timeTable->getSubject() === $this) {
  588.                 $timeTable->setSubject(null);
  589.             }
  590.         }
  592.         return $this;
  593.     }
  594. }