src/Entity/Exams.php line 15

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\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use JMS\Serializer\Annotation\Groups;
  13. #[ORM\HasLifecycleCallbacks]
  14. #[ORM\Entity(repositoryClass: ExamsRepository::class)]
  15. class Exams
  16. {
  17.     use Timestampable;
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     #[Groups(['note','getBulletin','getExamStudent', 'getStatsStudentParentIndex'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  26.     private ?string $name = null;
  28.     #[ORM\Column]
  29.     #[Groups(['note'])]
  30.     private ?float $coef = null;
  32.     #[ORM\OneToMany(mappedBy: 'exams', targetEntity: Note::class)]
  33.     private Collection $notes;
  35.     #[ORM\Column(nullable: true)]
  36.     #[Groups(['note'])]
  37.     private ?bool $control = null;
  39.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  40.     private ?SchoolYear $year = null;
  42.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  43.     private ?Subject $subject = null;
  45.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  46.     private ?User $author = null;
  48.     #[ORM\ManyToOne(inversedBy: 'examsEdited', cascade: ["persist"])]
  49.     private ?User $editor = null;
  51.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: SubSequence::class, orphanRemoval: true)]
  52.     private Collection $subSequences;
  54.     #[ORM\ManyToOne(inversedBy: 'exams')]
  55.     #[ORM\JoinColumn(nullable: false)]
  56.     private ?Quarter $quarter = null;
  58.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Absence::class, orphanRemoval: true)]
  59.     private Collection $absences;
  61.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Late::class, orphanRemoval: true)]
  62.     private Collection $lates;
  64.     #[ORM\ManyToOne(inversedBy: 'exams')]
  65.     #[ORM\JoinColumn(nullable: true)]
  66.     private ?GlobalExam $globalExam = null;
  68.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ParentNote::class)]
  69.     private Collection $parentNotes;
  71.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineBlame::class)]
  72.     private Collection $disciplineBlames;
  74.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineWarning::class)]
  75.     private Collection $disciplineWarnings;
  77.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineRetained::class)]
  78.     private Collection $disciplineRetaineds;
  80.     #[ORM\Column(length: 255, nullable: true)]
  81.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  82.     private ?string $nameEn = null;
  84.     #[ORM\Column(nullable: true)]
  85.     private ?int $type = null;
  87.     #[ORM\Column(nullable: true)]
  88.     private ?int $dividend = null;
  90.     #[ORM\Column(length: 255, nullable: true)]
  91.     private ?string $primaryName = null;
  93.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplinePunish::class)]
  94.     private Collection $disciplinePunishes;
  96.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Retained::class)]
  97.     private Collection $retaineds;
  99.     #[ORM\Column(length: 255, nullable: true)]
  100.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex'])]
  101.     private ?string $slug = null;
  103.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineConcile::class)]
  104.     private Collection $disciplineConciles;
  106.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineExclusion::class)]
  107.     private Collection $disciplineExclusions;
  109.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ExamWeek::class)]
  110.     private Collection $examWeeks;
  112.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Competence::class)]
  113.     private Collection $competences;
  115.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ProfSchoolPlanner::class)]
  116.     private Collection $profSchoolPlanners;
  118.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ProfTime::class)]
  119.     private Collection $profTimes;
  121.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  122.     private ?\DateTimeInterface $startAt = null;
  124.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  125.     private ?\DateTimeImmutable $endAt = null;
  127.     public function __construct()
  128.     {
  129.         $this->notes = new ArrayCollection();
  130.         $this->subSequences = new ArrayCollection();
  131.         $this->absences = new ArrayCollection();
  132.         $this->lates = new ArrayCollection();
  133.         $this->parentNotes = new ArrayCollection();
  134.         $this->disciplineBlames = new ArrayCollection();
  135.         $this->disciplineWarnings = new ArrayCollection();
  136.         $this->disciplineRetaineds = new ArrayCollection();
  137.         $this->disciplinePunishes = new ArrayCollection();
  138.         $this->retaineds = new ArrayCollection();
  139.         $this->disciplineConciles = new ArrayCollection();
  140.         $this->disciplineExclusions = new ArrayCollection();
  141.         $this->examWeeks = new ArrayCollection();
  142.         $this->competences = new ArrayCollection();
  143.         $this->profSchoolPlanners = new ArrayCollection();
  144.         $this->profTimes = new ArrayCollection();
  145.     }
  147.     public function __toString(): string
  148.     {
  149.         return $this->getName();
  150.     }
  152.     public function getId(): ?int
  153.     {
  154.         return $this->id;
  155.     }
  157.     public function getName(): ?string
  158.     {
  159.         return $this->name;
  160.     }
  162.     public function setName(string $name): static
  163.     {
  164.         $this->name = $name;
  166.         return $this;
  167.     }
  169.     public function getCoef(): ?float
  170.     {
  171.         return $this->coef;
  172.     }
  174.     public function setCoef(float $coef): static
  175.     {
  176.         $this->coef = $coef;
  178.         return $this;
  179.     }
  181.     /**
  182.      * @return Collection<int, Note>
  183.      */
  184.     public function getNotes(): Collection
  185.     {
  186.         return $this->notes;
  187.     }
  189.     public function addNote(Note $note): static
  190.     {
  191.         if (!$this->notes->contains($note)) {
  192.             $this->notes->add($note);
  193.             $note->setExams($this);
  194.         }
  196.         return $this;
  197.     }
  199.     public function removeNote(Note $note): static
  200.     {
  201.         if ($this->notes->removeElement($note)) {
  202.             // set the owning side to null (unless already changed)
  203.             if ($note->getExams() === $this) {
  204.                 $note->setExams(null);
  205.             }
  206.         }
  208.         return $this;
  209.     }
  211.     public function isControl(): ?bool
  212.     {
  213.         return $this->control;
  214.     }
  216.     public function setControl(?bool $control): static
  217.     {
  218.         $this->control = $control;
  220.         return $this;
  221.     }
  223.     public function getYear(): ?SchoolYear
  224.     {
  225.         return $this->year;
  226.     }
  228.     public function setYear(?SchoolYear $year): static
  229.     {
  230.         $this->year = $year;
  232.         return $this;
  233.     }
  235.     public function getSubject(): ?Subject
  236.     {
  237.         return $this->subject;
  238.     }
  240.     public function setSubject(?Subject $subject): static
  241.     {
  242.         $this->subject = $subject;
  244.         return $this;
  245.     }
  247.     public function getAuthor(): ?User
  248.     {
  249.         return $this->author;
  250.     }
  252.     public function setAuthor(?User $author): static
  253.     {
  254.         $this->author = $author;
  256.         return $this;
  257.     }
  259.     public function getEditor(): ?User
  260.     {
  261.         return $this->editor;
  262.     }
  264.     public function setEditor(?User $editor): static
  265.     {
  266.         $this->editor = $editor;
  268.         return $this;
  269.     }
  271.     /**
  272.      * @return Collection<int, SubSequence>
  273.      */
  274.     public function getSubSequences(): Collection
  275.     {
  276.         return $this->subSequences;
  277.     }
  279.     public function addSubSequence(SubSequence $subSequence): static
  280.     {
  281.         if (!$this->subSequences->contains($subSequence)) {
  282.             $this->subSequences->add($subSequence);
  283.             $subSequence->setExam($this);
  284.         }
  286.         return $this;
  287.     }
  289.     public function removeSubSequence(SubSequence $subSequence): static
  290.     {
  291.         if ($this->subSequences->removeElement($subSequence)) {
  292.             // set the owning side to null (unless already changed)
  293.             if ($subSequence->getExam() === $this) {
  294.                 $subSequence->setExam(null);
  295.             }
  296.         }
  298.         return $this;
  299.     }
  301.     public function getQuarter(): ?Quarter
  302.     {
  303.         return $this->quarter;
  304.     }
  306.     public function setQuarter(?Quarter $quarter): static
  307.     {
  308.         $this->quarter = $quarter;
  310.         return $this;
  311.     }
  313.     /**
  314.      * @return Collection<int, Absence>
  315.      */
  316.     public function getAbsences(): Collection
  317.     {
  318.         return $this->absences;
  319.     }
  321.     public function addAbsence(Absence $absence): static
  322.     {
  323.         if (!$this->absences->contains($absence)) {
  324.             $this->absences->add($absence);
  325.             $absence->setExam($this);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeAbsence(Absence $absence): static
  332.     {
  333.         if ($this->absences->removeElement($absence)) {
  334.             // set the owning side to null (unless already changed)
  335.             if ($absence->getExam() === $this) {
  336.                 $absence->setExam(null);
  337.             }
  338.         }
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Late>
  345.      */
  346.     public function getLates(): Collection
  347.     {
  348.         return $this->lates;
  349.     }
  351.     public function addLate(Late $late): static
  352.     {
  353.         if (!$this->lates->contains($late)) {
  354.             $this->lates->add($late);
  355.             $late->setExam($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeLate(Late $late): static
  362.     {
  363.         if ($this->lates->removeElement($late)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($late->getExam() === $this) {
  366.                 $late->setExam(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     public function getGlobalExam(): ?GlobalExam
  374.     {
  375.         return $this->globalExam;
  376.     }
  378.     public function setGlobalExam(?GlobalExam $globalExam): static
  379.     {
  380.         $this->globalExam = $globalExam;
  382.         return $this;
  383.     }
  385.     /**
  386.      * @return Collection<int, ParentNote>
  387.      */
  388.     public function getParentNotes(): Collection
  389.     {
  390.         return $this->parentNotes;
  391.     }
  393.     public function addParentNote(ParentNote $parentNote): static
  394.     {
  395.         if (!$this->parentNotes->contains($parentNote)) {
  396.             $this->parentNotes->add($parentNote);
  397.             $parentNote->setExam($this);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeParentNote(ParentNote $parentNote): static
  404.     {
  405.         if ($this->parentNotes->removeElement($parentNote)) {
  406.             // set the owning side to null (unless already changed)
  407.             if ($parentNote->getExam() === $this) {
  408.                 $parentNote->setExam(null);
  409.             }
  410.         }
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return Collection<int, DisciplineBlame>
  417.      */
  418.     public function getDisciplineBlames(): Collection
  419.     {
  420.         return $this->disciplineBlames;
  421.     }
  423.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  424.     {
  425.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  426.             $this->disciplineBlames->add($disciplineBlame);
  427.             $disciplineBlame->setExam($this);
  428.         }
  430.         return $this;
  431.     }
  433.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  434.     {
  435.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  436.             // set the owning side to null (unless already changed)
  437.             if ($disciplineBlame->getExam() === $this) {
  438.                 $disciplineBlame->setExam(null);
  439.             }
  440.         }
  442.         return $this;
  443.     }
  445.     /**
  446.      * @return Collection<int, DisciplineWarning>
  447.      */
  448.     public function getDisciplineWarnings(): Collection
  449.     {
  450.         return $this->disciplineWarnings;
  451.     }
  453.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  454.     {
  455.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  456.             $this->disciplineWarnings->add($disciplineWarning);
  457.             $disciplineWarning->setExam($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  464.     {
  465.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  466.             // set the owning side to null (unless already changed)
  467.             if ($disciplineWarning->getExam() === $this) {
  468.                 $disciplineWarning->setExam(null);
  469.             }
  470.         }
  472.         return $this;
  473.     }
  475.     /**
  476.      * @return Collection<int, DisciplineRetained>
  477.      */
  478.     public function getDisciplineRetaineds(): Collection
  479.     {
  480.         return $this->disciplineRetaineds;
  481.     }
  483.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  484.     {
  485.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  486.             $this->disciplineRetaineds->add($disciplineRetained);
  487.             $disciplineRetained->setExam($this);
  488.         }
  490.         return $this;
  491.     }
  493.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  494.     {
  495.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  496.             // set the owning side to null (unless already changed)
  497.             if ($disciplineRetained->getExam() === $this) {
  498.                 $disciplineRetained->setExam(null);
  499.             }
  500.         }
  502.         return $this;
  503.     }
  505.     public function getNameEn(): ?string
  506.     {
  507.         return $this->nameEn;
  508.     }
  510.     public function setNameEn(?string $nameEn): static
  511.     {
  512.         $this->nameEn = $nameEn;
  514.         return $this;
  515.     }
  517.     public function getType(): ?int
  518.     {
  519.         return $this->type;
  520.     }
  522.     public function setType(?int $type): static
  523.     {
  524.         $this->type = $type;
  526.         return $this;
  527.     }
  529.     public function getDividend(): ?int
  530.     {
  531.         return $this->dividend;
  532.     }
  534.     public function setDividend(?int $dividend): static
  535.     {
  536.         $this->dividend = $dividend;
  538.         return $this;
  539.     }
  541.     public function getPrimaryName(): ?string
  542.     {
  543.         return $this->primaryName;
  544.     }
  546.     public function setPrimaryName(?string $primaryName): static
  547.     {
  548.         $this->primaryName = $primaryName;
  550.         return $this;
  551.     }
  553.     /**
  554.      * @return Collection<int, DisciplinePunish>
  555.      */
  556.     public function getDisciplinePunishes(): Collection
  557.     {
  558.         return $this->disciplinePunishes;
  559.     }
  561.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  562.     {
  563.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  564.             $this->disciplinePunishes->add($disciplinePunish);
  565.             $disciplinePunish->setExam($this);
  566.         }
  568.         return $this;
  569.     }
  571.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  572.     {
  573.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  574.             // set the owning side to null (unless already changed)
  575.             if ($disciplinePunish->getExam() === $this) {
  576.                 $disciplinePunish->setExam(null);
  577.             }
  578.         }
  580.         return $this;
  581.     }
  583.     /**
  584.      * @return Collection<int, Retained>
  585.      */
  586.     public function getRetaineds(): Collection
  587.     {
  588.         return $this->retaineds;
  589.     }
  591.     public function addRetained(Retained $retained): static
  592.     {
  593.         if (!$this->retaineds->contains($retained)) {
  594.             $this->retaineds->add($retained);
  595.             $retained->setExam($this);
  596.         }
  598.         return $this;
  599.     }
  601.     public function removeRetained(Retained $retained): static
  602.     {
  603.         if ($this->retaineds->removeElement($retained)) {
  604.             // set the owning side to null (unless already changed)
  605.             if ($retained->getExam() === $this) {
  606.                 $retained->setExam(null);
  607.             }
  608.         }
  610.         return $this;
  611.     }
  613.     public function getSlug(): ?string
  614.     {
  615.         return $this->slug;
  616.     }
  618.     public function setSlug(?string $slug): static
  619.     {
  620.         $this->slug = $slug;
  622.         return $this;
  623.     }
  625.     /**
  626.      * @return Collection<int, DisciplineConcile>
  627.      */
  628.     public function getDisciplineConciles(): Collection
  629.     {
  630.         return $this->disciplineConciles;
  631.     }
  633.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  634.     {
  635.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  636.             $this->disciplineConciles->add($disciplineConcile);
  637.             $disciplineConcile->setExam($this);
  638.         }
  640.         return $this;
  641.     }
  643.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  644.     {
  645.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  646.             // set the owning side to null (unless already changed)
  647.             if ($disciplineConcile->getExam() === $this) {
  648.                 $disciplineConcile->setExam(null);
  649.             }
  650.         }
  652.         return $this;
  653.     }
  655.     /**
  656.      * @return Collection<int, DisciplineExclusion>
  657.      */
  658.     public function getDisciplineExclusions(): Collection
  659.     {
  660.         return $this->disciplineExclusions;
  661.     }
  663.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  664.     {
  665.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  666.             $this->disciplineExclusions->add($disciplineExclusion);
  667.             $disciplineExclusion->setExam($this);
  668.         }
  670.         return $this;
  671.     }
  673.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  674.     {
  675.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  676.             // set the owning side to null (unless already changed)
  677.             if ($disciplineExclusion->getExam() === $this) {
  678.                 $disciplineExclusion->setExam(null);
  679.             }
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection<int, ExamWeek>
  687.      */
  688.     public function getExamWeeks(): Collection
  689.     {
  690.         return $this->examWeeks;
  691.     }
  693.     public function addExamWeek(ExamWeek $examWeek): static
  694.     {
  695.         if (!$this->examWeeks->contains($examWeek)) {
  696.             $this->examWeeks->add($examWeek);
  697.             $examWeek->setExam($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeExamWeek(ExamWeek $examWeek): static
  704.     {
  705.         if ($this->examWeeks->removeElement($examWeek)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($examWeek->getExam() === $this) {
  708.                 $examWeek->setExam(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, Competence>
  717.      */
  718.     public function getCompetences(): Collection
  719.     {
  720.         return $this->competences;
  721.     }
  723.     public function addCompetence(Competence $competence): static
  724.     {
  725.         if (!$this->competences->contains($competence)) {
  726.             $this->competences->add($competence);
  727.             $competence->setExam($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removeCompetence(Competence $competence): static
  734.     {
  735.         if ($this->competences->removeElement($competence)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($competence->getExam() === $this) {
  738.                 $competence->setExam(null);
  739.             }
  740.         }
  742.         return $this;
  743.     }
  745.     /**
  746.      * @return Collection<int, ProfSchoolPlanner>
  747.      */
  748.     public function getProfSchoolPlanners(): Collection
  749.     {
  750.         return $this->profSchoolPlanners;
  751.     }
  753.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  754.     {
  755.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  756.             $this->profSchoolPlanners->add($profSchoolPlanner);
  757.             $profSchoolPlanner->setExam($this);
  758.         }
  760.         return $this;
  761.     }
  763.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  764.     {
  765.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  766.             // set the owning side to null (unless already changed)
  767.             if ($profSchoolPlanner->getExam() === $this) {
  768.                 $profSchoolPlanner->setExam(null);
  769.             }
  770.         }
  772.         return $this;
  773.     }
  775.     /**
  776.      * @return Collection<int, ProfTime>
  777.      */
  778.     public function getProfTimes(): Collection
  779.     {
  780.         return $this->profTimes;
  781.     }
  783.     public function addProfTime(ProfTime $profTime): static
  784.     {
  785.         if (!$this->profTimes->contains($profTime)) {
  786.             $this->profTimes->add($profTime);
  787.             $profTime->setExam($this);
  788.         }
  790.         return $this;
  791.     }
  793.     public function removeProfTime(ProfTime $profTime): static
  794.     {
  795.         if ($this->profTimes->removeElement($profTime)) {
  796.             // set the owning side to null (unless already changed)
  797.             if ($profTime->getExam() === $this) {
  798.                 $profTime->setExam(null);
  799.             }
  800.         }
  802.         return $this;
  803.     }
  805.     public function getStartAt(): ?\DateTimeInterface
  806.     {
  807.         return $this->startAt;
  808.     }
  810.     public function setStartAt(?\DateTimeInterface $startAt): static
  811.     {
  812.         $this->startAt = $startAt;
  814.         return $this;
  815.     }
  817.     public function getEndAt(): ?\DateTimeImmutable
  818.     {
  819.         return $this->endAt;
  820.     }
  822.     public function setEndAt(?\DateTimeImmutable $endAt): static
  823.     {
  824.         $this->endAt = $endAt;
  826.         return $this;
  827.     }
  828. }