src/Entity/Exams.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\Timestampable;
  6. use App\Repository\ExamsRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use JMS\Serializer\Annotation\Groups;
  12. #[ORM\HasLifecycleCallbacks]
  13. #[ORM\Entity(repositoryClass: ExamsRepository::class)]
  14. class Exams
  15. {
  16.     use Timestampable;
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     #[Groups(['note','getBulletin','getExamStudent'])]
  21.     private ?int $id = null;
  23.     #[ORM\Column(length: 255)]
  24.     #[Groups(['note','getBulletin','getExamStudent'])]
  25.     private ?string $name = null;
  27.     #[ORM\Column]
  28.     #[Groups(['note'])]
  29.     private ?float $coef = null;
  31.     #[ORM\OneToMany(mappedBy: 'exams', targetEntity: Note::class)]
  32.     private Collection $notes;
  34.     #[ORM\Column(nullable: true)]
  35.     #[Groups(['note'])]
  36.     private ?bool $control = null;
  38.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  39.     private ?SchoolYear $year = null;
  41.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  42.     private ?TheClass $classe = null;
  44.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  45.     private ?Subject $subject = null;
  47.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  48.     private ?User $author = null;
  50.     #[ORM\ManyToOne(inversedBy: 'examsEdited', cascade: ["persist"])]
  51.     private ?User $editor = null;
  53.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  54.     private ?School $school = null;
  56.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: SubSequence::class, orphanRemoval: true)]
  57.     private Collection $subSequences;
  59.     #[ORM\ManyToOne(inversedBy: 'exams')]
  60.     #[ORM\JoinColumn(nullable: true)]
  61.     private ?Quarter $quarter = null;
  63.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Absence::class, orphanRemoval: true)]
  64.     private Collection $absences;
  66.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Late::class, orphanRemoval: true)]
  67.     private Collection $lates;
  69.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Punish::class, orphanRemoval: true)]
  70.     private Collection $punishes;
  72.     #[ORM\ManyToOne(inversedBy: 'exams')]
  73.     #[ORM\JoinColumn(nullable: true)]
  74.     private ?GlobalExam $globalExam = null;
  76.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ParentNote::class)]
  77.     private Collection $parentNotes;
  79.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineBlame::class)]
  80.     private Collection $disciplineBlames;
  82.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineWarning::class)]
  83.     private Collection $disciplineWarnings;
  85.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineRetained::class)]
  86.     private Collection $disciplineRetaineds;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     private ?string $nameEn = null;
  91.     #[ORM\Column(nullable: true)]
  92.     private ?int $type = null;
  94.     #[ORM\Column(nullable: true)]
  95.     private ?int $dividend = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $primaryName = null;
  100.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplinePunish::class)]
  101.     private Collection $disciplinePunishes;
  103.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Retained::class)]
  104.     private Collection $retaineds;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     private ?string $slug = null;
  109.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineConcile::class)]
  110.     private Collection $disciplineConciles;
  112.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineExclusion::class)]
  113.     private Collection $disciplineExclusions;
  115.     public function __construct()
  116.     {
  117.         $this->notes = new ArrayCollection();
  118.         $this->subSequences = new ArrayCollection();
  119.         $this->absences = new ArrayCollection();
  120.         $this->lates = new ArrayCollection();
  121.         $this->punishes = new ArrayCollection();
  122.         $this->parentNotes = new ArrayCollection();
  123.         $this->disciplineBlames = new ArrayCollection();
  124.         $this->disciplineWarnings = new ArrayCollection();
  125.         $this->disciplineRetaineds = new ArrayCollection();
  126.         $this->disciplinePunishes = new ArrayCollection();
  127.         $this->retaineds = new ArrayCollection();
  128.         $this->disciplineConciles = new ArrayCollection();
  129.         $this->disciplineExclusions = new ArrayCollection();
  130.     }
  132.     public function __toString(): string
  133.     {
  134.         return $this->getName();
  135.     }
  137.     public function getId(): ?int
  138.     {
  139.         return $this->id;
  140.     }
  142.     public function getName(): ?string
  143.     {
  144.         return $this->name;
  145.     }
  147.     public function setName(string $name): static
  148.     {
  149.         $this->name = $name;
  151.         return $this;
  152.     }
  154.     public function getCoef(): ?float
  155.     {
  156.         return $this->coef;
  157.     }
  159.     public function setCoef(float $coef): static
  160.     {
  161.         $this->coef = $coef;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @return Collection<int, Note>
  168.      */
  169.     public function getNotes(): Collection
  170.     {
  171.         return $this->notes;
  172.     }
  174.     public function addNote(Note $note): static
  175.     {
  176.         if (!$this->notes->contains($note)) {
  177.             $this->notes->add($note);
  178.             $note->setExams($this);
  179.         }
  181.         return $this;
  182.     }
  184.     public function removeNote(Note $note): static
  185.     {
  186.         if ($this->notes->removeElement($note)) {
  187.             // set the owning side to null (unless already changed)
  188.             if ($note->getExams() === $this) {
  189.                 $note->setExams(null);
  190.             }
  191.         }
  193.         return $this;
  194.     }
  196.     public function isControl(): ?bool
  197.     {
  198.         return $this->control;
  199.     }
  201.     public function setControl(?bool $control): static
  202.     {
  203.         $this->control = $control;
  205.         return $this;
  206.     }
  208.     public function getYear(): ?SchoolYear
  209.     {
  210.         return $this->year;
  211.     }
  213.     public function setYear(?SchoolYear $year): static
  214.     {
  215.         $this->year = $year;
  217.         return $this;
  218.     }
  220.     public function getClasse(): ?TheClass
  221.     {
  222.         return $this->classe;
  223.     }
  225.     public function setClasse(?TheClass $classe): static
  226.     {
  227.         $this->classe = $classe;
  229.         return $this;
  230.     }
  232.     public function getSubject(): ?Subject
  233.     {
  234.         return $this->subject;
  235.     }
  237.     public function setSubject(?Subject $subject): static
  238.     {
  239.         $this->subject = $subject;
  241.         return $this;
  242.     }
  244.     public function getAuthor(): ?User
  245.     {
  246.         return $this->author;
  247.     }
  249.     public function setAuthor(?User $author): static
  250.     {
  251.         $this->author = $author;
  253.         return $this;
  254.     }
  256.     public function getEditor(): ?User
  257.     {
  258.         return $this->editor;
  259.     }
  261.     public function setEditor(?User $editor): static
  262.     {
  263.         $this->editor = $editor;
  265.         return $this;
  266.     }
  268.     public function getSchool(): ?School
  269.     {
  270.         return $this->school;
  271.     }
  273.     public function setSchool(?School $school): static
  274.     {
  275.         $this->school = $school;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return Collection<int, SubSequence>
  282.      */
  283.     public function getSubSequences(): Collection
  284.     {
  285.         return $this->subSequences;
  286.     }
  288.     public function addSubSequence(SubSequence $subSequence): static
  289.     {
  290.         if (!$this->subSequences->contains($subSequence)) {
  291.             $this->subSequences->add($subSequence);
  292.             $subSequence->setExam($this);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeSubSequence(SubSequence $subSequence): static
  299.     {
  300.         if ($this->subSequences->removeElement($subSequence)) {
  301.             // set the owning side to null (unless already changed)
  302.             if ($subSequence->getExam() === $this) {
  303.                 $subSequence->setExam(null);
  304.             }
  305.         }
  307.         return $this;
  308.     }
  310.     public function getQuarter(): ?Quarter
  311.     {
  312.         return $this->quarter;
  313.     }
  315.     public function setQuarter(?Quarter $quarter): static
  316.     {
  317.         $this->quarter = $quarter;
  319.         return $this;
  320.     }
  322.     /**
  323.      * @return Collection<int, Absence>
  324.      */
  325.     public function getAbsences(): Collection
  326.     {
  327.         return $this->absences;
  328.     }
  330.     public function addAbsence(Absence $absence): static
  331.     {
  332.         if (!$this->absences->contains($absence)) {
  333.             $this->absences->add($absence);
  334.             $absence->setExam($this);
  335.         }
  337.         return $this;
  338.     }
  340.     public function removeAbsence(Absence $absence): static
  341.     {
  342.         if ($this->absences->removeElement($absence)) {
  343.             // set the owning side to null (unless already changed)
  344.             if ($absence->getExam() === $this) {
  345.                 $absence->setExam(null);
  346.             }
  347.         }
  349.         return $this;
  350.     }
  352.     /**
  353.      * @return Collection<int, Late>
  354.      */
  355.     public function getLates(): Collection
  356.     {
  357.         return $this->lates;
  358.     }
  360.     public function addLate(Late $late): static
  361.     {
  362.         if (!$this->lates->contains($late)) {
  363.             $this->lates->add($late);
  364.             $late->setExam($this);
  365.         }
  367.         return $this;
  368.     }
  370.     public function removeLate(Late $late): static
  371.     {
  372.         if ($this->lates->removeElement($late)) {
  373.             // set the owning side to null (unless already changed)
  374.             if ($late->getExam() === $this) {
  375.                 $late->setExam(null);
  376.             }
  377.         }
  379.         return $this;
  380.     }
  382.     /**
  383.      * @return Collection<int, Punish>
  384.      */
  385.     public function getPunishes(): Collection
  386.     {
  387.         return $this->punishes;
  388.     }
  390.     public function addPunish(Punish $punish): static
  391.     {
  392.         if (!$this->punishes->contains($punish)) {
  393.             $this->punishes->add($punish);
  394.             $punish->setExam($this);
  395.         }
  397.         return $this;
  398.     }
  400.     public function removePunish(Punish $punish): static
  401.     {
  402.         if ($this->punishes->removeElement($punish)) {
  403.             // set the owning side to null (unless already changed)
  404.             if ($punish->getExam() === $this) {
  405.                 $punish->setExam(null);
  406.             }
  407.         }
  409.         return $this;
  410.     }
  412.     public function getGlobalExam(): ?GlobalExam
  413.     {
  414.         return $this->globalExam;
  415.     }
  417.     public function setGlobalExam(?GlobalExam $globalExam): static
  418.     {
  419.         $this->globalExam = $globalExam;
  421.         return $this;
  422.     }
  424.     /**
  425.      * @return Collection<int, ParentNote>
  426.      */
  427.     public function getParentNotes(): Collection
  428.     {
  429.         return $this->parentNotes;
  430.     }
  432.     public function addParentNote(ParentNote $parentNote): static
  433.     {
  434.         if (!$this->parentNotes->contains($parentNote)) {
  435.             $this->parentNotes->add($parentNote);
  436.             $parentNote->setExam($this);
  437.         }
  439.         return $this;
  440.     }
  442.     public function removeParentNote(ParentNote $parentNote): static
  443.     {
  444.         if ($this->parentNotes->removeElement($parentNote)) {
  445.             // set the owning side to null (unless already changed)
  446.             if ($parentNote->getExam() === $this) {
  447.                 $parentNote->setExam(null);
  448.             }
  449.         }
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection<int, DisciplineBlame>
  456.      */
  457.     public function getDisciplineBlames(): Collection
  458.     {
  459.         return $this->disciplineBlames;
  460.     }
  462.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  463.     {
  464.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  465.             $this->disciplineBlames->add($disciplineBlame);
  466.             $disciplineBlame->setExam($this);
  467.         }
  469.         return $this;
  470.     }
  472.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  473.     {
  474.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  475.             // set the owning side to null (unless already changed)
  476.             if ($disciplineBlame->getExam() === $this) {
  477.                 $disciplineBlame->setExam(null);
  478.             }
  479.         }
  481.         return $this;
  482.     }
  484.     /**
  485.      * @return Collection<int, DisciplineWarning>
  486.      */
  487.     public function getDisciplineWarnings(): Collection
  488.     {
  489.         return $this->disciplineWarnings;
  490.     }
  492.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  493.     {
  494.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  495.             $this->disciplineWarnings->add($disciplineWarning);
  496.             $disciplineWarning->setExam($this);
  497.         }
  499.         return $this;
  500.     }
  502.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  503.     {
  504.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  505.             // set the owning side to null (unless already changed)
  506.             if ($disciplineWarning->getExam() === $this) {
  507.                 $disciplineWarning->setExam(null);
  508.             }
  509.         }
  511.         return $this;
  512.     }
  514.     /**
  515.      * @return Collection<int, DisciplineRetained>
  516.      */
  517.     public function getDisciplineRetaineds(): Collection
  518.     {
  519.         return $this->disciplineRetaineds;
  520.     }
  522.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  523.     {
  524.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  525.             $this->disciplineRetaineds->add($disciplineRetained);
  526.             $disciplineRetained->setExam($this);
  527.         }
  529.         return $this;
  530.     }
  532.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  533.     {
  534.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  535.             // set the owning side to null (unless already changed)
  536.             if ($disciplineRetained->getExam() === $this) {
  537.                 $disciplineRetained->setExam(null);
  538.             }
  539.         }
  541.         return $this;
  542.     }
  544.     public function getNameEn(): ?string
  545.     {
  546.         return $this->nameEn;
  547.     }
  549.     public function setNameEn(?string $nameEn): static
  550.     {
  551.         $this->nameEn = $nameEn;
  553.         return $this;
  554.     }
  556.     public function getType(): ?int
  557.     {
  558.         return $this->type;
  559.     }
  561.     public function setType(?int $type): static
  562.     {
  563.         $this->type = $type;
  565.         return $this;
  566.     }
  568.     public function getDividend(): ?int
  569.     {
  570.         return $this->dividend;
  571.     }
  573.     public function setDividend(?int $dividend): static
  574.     {
  575.         $this->dividend = $dividend;
  577.         return $this;
  578.     }
  580.     public function getPrimaryName(): ?string
  581.     {
  582.         return $this->primaryName;
  583.     }
  585.     public function setPrimaryName(?string $primaryName): static
  586.     {
  587.         $this->primaryName = $primaryName;
  589.         return $this;
  590.     }
  592.     /**
  593.      * @return Collection<int, DisciplinePunish>
  594.      */
  595.     public function getDisciplinePunishes(): Collection
  596.     {
  597.         return $this->disciplinePunishes;
  598.     }
  600.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  601.     {
  602.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  603.             $this->disciplinePunishes->add($disciplinePunish);
  604.             $disciplinePunish->setExam($this);
  605.         }
  607.         return $this;
  608.     }
  610.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  611.     {
  612.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  613.             // set the owning side to null (unless already changed)
  614.             if ($disciplinePunish->getExam() === $this) {
  615.                 $disciplinePunish->setExam(null);
  616.             }
  617.         }
  619.         return $this;
  620.     }
  622.     /**
  623.      * @return Collection<int, Retained>
  624.      */
  625.     public function getRetaineds(): Collection
  626.     {
  627.         return $this->retaineds;
  628.     }
  630.     public function addRetained(Retained $retained): static
  631.     {
  632.         if (!$this->retaineds->contains($retained)) {
  633.             $this->retaineds->add($retained);
  634.             $retained->setExam($this);
  635.         }
  637.         return $this;
  638.     }
  640.     public function removeRetained(Retained $retained): static
  641.     {
  642.         if ($this->retaineds->removeElement($retained)) {
  643.             // set the owning side to null (unless already changed)
  644.             if ($retained->getExam() === $this) {
  645.                 $retained->setExam(null);
  646.             }
  647.         }
  649.         return $this;
  650.     }
  652.     public function getSlug(): ?string
  653.     {
  654.         return $this->slug;
  655.     }
  657.     public function setSlug(?string $slug): static
  658.     {
  659.         $this->slug = $slug;
  661.         return $this;
  662.     }
  664.     /**
  665.      * @return Collection<int, DisciplineConcile>
  666.      */
  667.     public function getDisciplineConciles(): Collection
  668.     {
  669.         return $this->disciplineConciles;
  670.     }
  672.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  673.     {
  674.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  675.             $this->disciplineConciles->add($disciplineConcile);
  676.             $disciplineConcile->setExam($this);
  677.         }
  679.         return $this;
  680.     }
  682.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  683.     {
  684.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  685.             // set the owning side to null (unless already changed)
  686.             if ($disciplineConcile->getExam() === $this) {
  687.                 $disciplineConcile->setExam(null);
  688.             }
  689.         }
  691.         return $this;
  692.     }
  694.     /**
  695.      * @return Collection<int, DisciplineExclusion>
  696.      */
  697.     public function getDisciplineExclusions(): Collection
  698.     {
  699.         return $this->disciplineExclusions;
  700.     }
  702.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  703.     {
  704.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  705.             $this->disciplineExclusions->add($disciplineExclusion);
  706.             $disciplineExclusion->setExam($this);
  707.         }
  709.         return $this;
  710.     }
  712.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  713.     {
  714.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  715.             // set the owning side to null (unless already changed)
  716.             if ($disciplineExclusion->getExam() === $this) {
  717.                 $disciplineExclusion->setExam(null);
  718.             }
  719.         }
  721.         return $this;
  722.     }
  723. }