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','getAbsence','getExamStudent','getLate','getPunish', '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.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  41.     private ?SchoolYear $year = null;
  43.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  44.     private ?Subject $subject = null;
  46.     #[ORM\ManyToOne(inversedBy: 'exams', cascade: ["persist"])]
  47.     private ?User $author = null;
  49.     #[ORM\ManyToOne(inversedBy: 'examsEdited', cascade: ["persist"])]
  50.     private ?User $editor = null;
  52.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: SubSequence::class, orphanRemoval: true)]
  53.     private Collection $subSequences;
  55.     #[ORM\ManyToOne(inversedBy: 'exams')]
  56.     #[ORM\JoinColumn(nullable: false)]
  57.     private ?Quarter $quarter = null;
  59.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Absence::class, orphanRemoval: true)]
  60.     private Collection $absences;
  62.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Late::class, orphanRemoval: true)]
  63.     private Collection $lates;
  65.     #[ORM\ManyToOne(inversedBy: 'exams')]
  66.     #[ORM\JoinColumn(nullable: true)]
  67.     private ?GlobalExam $globalExam = null;
  69.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ParentNote::class)]
  70.     private Collection $parentNotes;
  72.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineBlame::class)]
  73.     private Collection $disciplineBlames;
  75.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineWarning::class)]
  76.     private Collection $disciplineWarnings;
  78.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineRetained::class)]
  79.     private Collection $disciplineRetaineds;
  81.     #[ORM\Column(length: 255, nullable: true)]
  82.     #[Groups(['note','getBulletin','getExamStudent','getLate','getAbsence','getPunish', 'getStatsStudentParentIndex'])]
  83.     private ?string $nameEn = null;
  85.     #[ORM\Column(nullable: true)]
  86.     private ?int $type = null;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?int $dividend = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $primaryName = null;
  94.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplinePunish::class)]
  95.     private Collection $disciplinePunishes;
  97.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Retained::class)]
  98.     private Collection $retaineds;
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex', 'getAbsence'])]
  102.     private ?string $slug = null;
  104.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineConcile::class)]
  105.     private Collection $disciplineConciles;
  107.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: DisciplineExclusion::class)]
  108.     private Collection $disciplineExclusions;
  110.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ExamWeek::class)]
  111.     private Collection $examWeeks;
  113.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: Competence::class)]
  114.     private Collection $competences;
  116.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ProfSchoolPlanner::class)]
  117.     private Collection $profSchoolPlanners;
  119.     #[ORM\OneToMany(mappedBy: 'exam', targetEntity: ProfTime::class)]
  120.     private Collection $profTimes;
  122.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  123.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex', 'getAbsence'])]
  124.     private ?\DateTimeInterface $startAt = null;
  126.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  127.     #[Groups(['getExamStudent', 'getStatsStudentParentIndex', 'getAbsence'])]
  128.     private ?\DateTimeImmutable $endAt = null;
  130.     public function __construct()
  131.     {
  132.         $this->notes = new ArrayCollection();
  133.         $this->subSequences = new ArrayCollection();
  134.         $this->absences = new ArrayCollection();
  135.         $this->lates = new ArrayCollection();
  136.         $this->parentNotes = new ArrayCollection();
  137.         $this->disciplineBlames = new ArrayCollection();
  138.         $this->disciplineWarnings = new ArrayCollection();
  139.         $this->disciplineRetaineds = new ArrayCollection();
  140.         $this->disciplinePunishes = new ArrayCollection();
  141.         $this->retaineds = new ArrayCollection();
  142.         $this->disciplineConciles = new ArrayCollection();
  143.         $this->disciplineExclusions = new ArrayCollection();
  144.         $this->examWeeks = new ArrayCollection();
  145.         $this->competences = new ArrayCollection();
  146.         $this->profSchoolPlanners = new ArrayCollection();
  147.         $this->profTimes = new ArrayCollection();
  148.     }
  150.     public function __toString(): string
  151.     {
  152.         return $this->getName();
  153.     }
  155.     public function getId(): ?int
  156.     {
  157.         return $this->id;
  158.     }
  160.     public function getName(): ?string
  161.     {
  162.         return $this->name;
  163.     }
  165.     public function setName(string $name): static
  166.     {
  167.         $this->name = $name;
  169.         return $this;
  170.     }
  172.     public function getCoef(): ?float
  173.     {
  174.         return $this->coef;
  175.     }
  177.     public function setCoef(float $coef): static
  178.     {
  179.         $this->coef = $coef;
  181.         return $this;
  182.     }
  184.     /**
  185.      * @return Collection<int, Note>
  186.      */
  187.     public function getNotes(): Collection
  188.     {
  189.         return $this->notes;
  190.     }
  192.     public function addNote(Note $note): static
  193.     {
  194.         if (!$this->notes->contains($note)) {
  195.             $this->notes->add($note);
  196.             $note->setExams($this);
  197.         }
  199.         return $this;
  200.     }
  202.     public function removeNote(Note $note): static
  203.     {
  204.         if ($this->notes->removeElement($note)) {
  205.             // set the owning side to null (unless already changed)
  206.             if ($note->getExams() === $this) {
  207.                 $note->setExams(null);
  208.             }
  209.         }
  211.         return $this;
  212.     }
  214.     public function isControl(): ?bool
  215.     {
  216.         return $this->control;
  217.     }
  219.     public function setControl(?bool $control): static
  220.     {
  221.         $this->control = $control;
  223.         return $this;
  224.     }
  226.     public function getYear(): ?SchoolYear
  227.     {
  228.         return $this->year;
  229.     }
  231.     public function setYear(?SchoolYear $year): static
  232.     {
  233.         $this->year = $year;
  235.         return $this;
  236.     }
  238.     public function getSubject(): ?Subject
  239.     {
  240.         return $this->subject;
  241.     }
  243.     public function setSubject(?Subject $subject): static
  244.     {
  245.         $this->subject = $subject;
  247.         return $this;
  248.     }
  250.     public function getAuthor(): ?User
  251.     {
  252.         return $this->author;
  253.     }
  255.     public function setAuthor(?User $author): static
  256.     {
  257.         $this->author = $author;
  259.         return $this;
  260.     }
  262.     public function getEditor(): ?User
  263.     {
  264.         return $this->editor;
  265.     }
  267.     public function setEditor(?User $editor): static
  268.     {
  269.         $this->editor = $editor;
  271.         return $this;
  272.     }
  274.     /**
  275.      * @return Collection<int, SubSequence>
  276.      */
  277.     public function getSubSequences(): Collection
  278.     {
  279.         return $this->subSequences;
  280.     }
  282.     public function addSubSequence(SubSequence $subSequence): static
  283.     {
  284.         if (!$this->subSequences->contains($subSequence)) {
  285.             $this->subSequences->add($subSequence);
  286.             $subSequence->setExam($this);
  287.         }
  289.         return $this;
  290.     }
  292.     public function removeSubSequence(SubSequence $subSequence): static
  293.     {
  294.         if ($this->subSequences->removeElement($subSequence)) {
  295.             // set the owning side to null (unless already changed)
  296.             if ($subSequence->getExam() === $this) {
  297.                 $subSequence->setExam(null);
  298.             }
  299.         }
  301.         return $this;
  302.     }
  304.     public function getQuarter(): ?Quarter
  305.     {
  306.         return $this->quarter;
  307.     }
  309.     public function setQuarter(?Quarter $quarter): static
  310.     {
  311.         $this->quarter = $quarter;
  313.         return $this;
  314.     }
  316.     /**
  317.      * @return Collection<int, Absence>
  318.      */
  319.     public function getAbsences(): Collection
  320.     {
  321.         return $this->absences;
  322.     }
  324.     public function addAbsence(Absence $absence): static
  325.     {
  326.         if (!$this->absences->contains($absence)) {
  327.             $this->absences->add($absence);
  328.             $absence->setExam($this);
  329.         }
  331.         return $this;
  332.     }
  334.     public function removeAbsence(Absence $absence): static
  335.     {
  336.         if ($this->absences->removeElement($absence)) {
  337.             // set the owning side to null (unless already changed)
  338.             if ($absence->getExam() === $this) {
  339.                 $absence->setExam(null);
  340.             }
  341.         }
  343.         return $this;
  344.     }
  346.     /**
  347.      * @return Collection<int, Late>
  348.      */
  349.     public function getLates(): Collection
  350.     {
  351.         return $this->lates;
  352.     }
  354.     public function addLate(Late $late): static
  355.     {
  356.         if (!$this->lates->contains($late)) {
  357.             $this->lates->add($late);
  358.             $late->setExam($this);
  359.         }
  361.         return $this;
  362.     }
  364.     public function removeLate(Late $late): static
  365.     {
  366.         if ($this->lates->removeElement($late)) {
  367.             // set the owning side to null (unless already changed)
  368.             if ($late->getExam() === $this) {
  369.                 $late->setExam(null);
  370.             }
  371.         }
  373.         return $this;
  374.     }
  376.     public function getGlobalExam(): ?GlobalExam
  377.     {
  378.         return $this->globalExam;
  379.     }
  381.     public function setGlobalExam(?GlobalExam $globalExam): static
  382.     {
  383.         $this->globalExam = $globalExam;
  385.         return $this;
  386.     }
  388.     /**
  389.      * @return Collection<int, ParentNote>
  390.      */
  391.     public function getParentNotes(): Collection
  392.     {
  393.         return $this->parentNotes;
  394.     }
  396.     public function addParentNote(ParentNote $parentNote): static
  397.     {
  398.         if (!$this->parentNotes->contains($parentNote)) {
  399.             $this->parentNotes->add($parentNote);
  400.             $parentNote->setExam($this);
  401.         }
  403.         return $this;
  404.     }
  406.     public function removeParentNote(ParentNote $parentNote): static
  407.     {
  408.         if ($this->parentNotes->removeElement($parentNote)) {
  409.             // set the owning side to null (unless already changed)
  410.             if ($parentNote->getExam() === $this) {
  411.                 $parentNote->setExam(null);
  412.             }
  413.         }
  415.         return $this;
  416.     }
  418.     /**
  419.      * @return Collection<int, DisciplineBlame>
  420.      */
  421.     public function getDisciplineBlames(): Collection
  422.     {
  423.         return $this->disciplineBlames;
  424.     }
  426.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  427.     {
  428.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  429.             $this->disciplineBlames->add($disciplineBlame);
  430.             $disciplineBlame->setExam($this);
  431.         }
  433.         return $this;
  434.     }
  436.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  437.     {
  438.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  439.             // set the owning side to null (unless already changed)
  440.             if ($disciplineBlame->getExam() === $this) {
  441.                 $disciplineBlame->setExam(null);
  442.             }
  443.         }
  445.         return $this;
  446.     }
  448.     /**
  449.      * @return Collection<int, DisciplineWarning>
  450.      */
  451.     public function getDisciplineWarnings(): Collection
  452.     {
  453.         return $this->disciplineWarnings;
  454.     }
  456.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  457.     {
  458.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  459.             $this->disciplineWarnings->add($disciplineWarning);
  460.             $disciplineWarning->setExam($this);
  461.         }
  463.         return $this;
  464.     }
  466.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  467.     {
  468.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  469.             // set the owning side to null (unless already changed)
  470.             if ($disciplineWarning->getExam() === $this) {
  471.                 $disciplineWarning->setExam(null);
  472.             }
  473.         }
  475.         return $this;
  476.     }
  478.     /**
  479.      * @return Collection<int, DisciplineRetained>
  480.      */
  481.     public function getDisciplineRetaineds(): Collection
  482.     {
  483.         return $this->disciplineRetaineds;
  484.     }
  486.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  487.     {
  488.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  489.             $this->disciplineRetaineds->add($disciplineRetained);
  490.             $disciplineRetained->setExam($this);
  491.         }
  493.         return $this;
  494.     }
  496.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  497.     {
  498.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  499.             // set the owning side to null (unless already changed)
  500.             if ($disciplineRetained->getExam() === $this) {
  501.                 $disciplineRetained->setExam(null);
  502.             }
  503.         }
  505.         return $this;
  506.     }
  508.     public function getNameEn(): ?string
  509.     {
  510.         return $this->nameEn;
  511.     }
  513.     public function setNameEn(?string $nameEn): static
  514.     {
  515.         $this->nameEn = $nameEn;
  517.         return $this;
  518.     }
  520.     public function getType(): ?int
  521.     {
  522.         return $this->type;
  523.     }
  525.     public function setType(?int $type): static
  526.     {
  527.         $this->type = $type;
  529.         return $this;
  530.     }
  532.     public function getDividend(): ?int
  533.     {
  534.         return $this->dividend;
  535.     }
  537.     public function setDividend(?int $dividend): static
  538.     {
  539.         $this->dividend = $dividend;
  541.         return $this;
  542.     }
  544.     public function getPrimaryName(): ?string
  545.     {
  546.         return $this->primaryName;
  547.     }
  549.     public function setPrimaryName(?string $primaryName): static
  550.     {
  551.         $this->primaryName = $primaryName;
  553.         return $this;
  554.     }
  556.     /**
  557.      * @return Collection<int, DisciplinePunish>
  558.      */
  559.     public function getDisciplinePunishes(): Collection
  560.     {
  561.         return $this->disciplinePunishes;
  562.     }
  564.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  565.     {
  566.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  567.             $this->disciplinePunishes->add($disciplinePunish);
  568.             $disciplinePunish->setExam($this);
  569.         }
  571.         return $this;
  572.     }
  574.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  575.     {
  576.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  577.             // set the owning side to null (unless already changed)
  578.             if ($disciplinePunish->getExam() === $this) {
  579.                 $disciplinePunish->setExam(null);
  580.             }
  581.         }
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return Collection<int, Retained>
  588.      */
  589.     public function getRetaineds(): Collection
  590.     {
  591.         return $this->retaineds;
  592.     }
  594.     public function addRetained(Retained $retained): static
  595.     {
  596.         if (!$this->retaineds->contains($retained)) {
  597.             $this->retaineds->add($retained);
  598.             $retained->setExam($this);
  599.         }
  601.         return $this;
  602.     }
  604.     public function removeRetained(Retained $retained): static
  605.     {
  606.         if ($this->retaineds->removeElement($retained)) {
  607.             // set the owning side to null (unless already changed)
  608.             if ($retained->getExam() === $this) {
  609.                 $retained->setExam(null);
  610.             }
  611.         }
  613.         return $this;
  614.     }
  616.     public function getSlug(): ?string
  617.     {
  618.         return $this->slug;
  619.     }
  621.     public function setSlug(?string $slug): static
  622.     {
  623.         $this->slug = $slug;
  625.         return $this;
  626.     }
  628.     /**
  629.      * @return Collection<int, DisciplineConcile>
  630.      */
  631.     public function getDisciplineConciles(): Collection
  632.     {
  633.         return $this->disciplineConciles;
  634.     }
  636.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  637.     {
  638.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  639.             $this->disciplineConciles->add($disciplineConcile);
  640.             $disciplineConcile->setExam($this);
  641.         }
  643.         return $this;
  644.     }
  646.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  647.     {
  648.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  649.             // set the owning side to null (unless already changed)
  650.             if ($disciplineConcile->getExam() === $this) {
  651.                 $disciplineConcile->setExam(null);
  652.             }
  653.         }
  655.         return $this;
  656.     }
  658.     /**
  659.      * @return Collection<int, DisciplineExclusion>
  660.      */
  661.     public function getDisciplineExclusions(): Collection
  662.     {
  663.         return $this->disciplineExclusions;
  664.     }
  666.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  667.     {
  668.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  669.             $this->disciplineExclusions->add($disciplineExclusion);
  670.             $disciplineExclusion->setExam($this);
  671.         }
  673.         return $this;
  674.     }
  676.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  677.     {
  678.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  679.             // set the owning side to null (unless already changed)
  680.             if ($disciplineExclusion->getExam() === $this) {
  681.                 $disciplineExclusion->setExam(null);
  682.             }
  683.         }
  685.         return $this;
  686.     }
  688.     /**
  689.      * @return Collection<int, ExamWeek>
  690.      */
  691.     public function getExamWeeks(): Collection
  692.     {
  693.         return $this->examWeeks;
  694.     }
  696.     public function addExamWeek(ExamWeek $examWeek): static
  697.     {
  698.         if (!$this->examWeeks->contains($examWeek)) {
  699.             $this->examWeeks->add($examWeek);
  700.             $examWeek->setExam($this);
  701.         }
  703.         return $this;
  704.     }
  706.     public function removeExamWeek(ExamWeek $examWeek): static
  707.     {
  708.         if ($this->examWeeks->removeElement($examWeek)) {
  709.             // set the owning side to null (unless already changed)
  710.             if ($examWeek->getExam() === $this) {
  711.                 $examWeek->setExam(null);
  712.             }
  713.         }
  715.         return $this;
  716.     }
  718.     /**
  719.      * @return Collection<int, Competence>
  720.      */
  721.     public function getCompetences(): Collection
  722.     {
  723.         return $this->competences;
  724.     }
  726.     public function addCompetence(Competence $competence): static
  727.     {
  728.         if (!$this->competences->contains($competence)) {
  729.             $this->competences->add($competence);
  730.             $competence->setExam($this);
  731.         }
  733.         return $this;
  734.     }
  736.     public function removeCompetence(Competence $competence): static
  737.     {
  738.         if ($this->competences->removeElement($competence)) {
  739.             // set the owning side to null (unless already changed)
  740.             if ($competence->getExam() === $this) {
  741.                 $competence->setExam(null);
  742.             }
  743.         }
  745.         return $this;
  746.     }
  748.     /**
  749.      * @return Collection<int, ProfSchoolPlanner>
  750.      */
  751.     public function getProfSchoolPlanners(): Collection
  752.     {
  753.         return $this->profSchoolPlanners;
  754.     }
  756.     public function addProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  757.     {
  758.         if (!$this->profSchoolPlanners->contains($profSchoolPlanner)) {
  759.             $this->profSchoolPlanners->add($profSchoolPlanner);
  760.             $profSchoolPlanner->setExam($this);
  761.         }
  763.         return $this;
  764.     }
  766.     public function removeProfSchoolPlanner(ProfSchoolPlanner $profSchoolPlanner): static
  767.     {
  768.         if ($this->profSchoolPlanners->removeElement($profSchoolPlanner)) {
  769.             // set the owning side to null (unless already changed)
  770.             if ($profSchoolPlanner->getExam() === $this) {
  771.                 $profSchoolPlanner->setExam(null);
  772.             }
  773.         }
  775.         return $this;
  776.     }
  778.     /**
  779.      * @return Collection<int, ProfTime>
  780.      */
  781.     public function getProfTimes(): Collection
  782.     {
  783.         return $this->profTimes;
  784.     }
  786.     public function addProfTime(ProfTime $profTime): static
  787.     {
  788.         if (!$this->profTimes->contains($profTime)) {
  789.             $this->profTimes->add($profTime);
  790.             $profTime->setExam($this);
  791.         }
  793.         return $this;
  794.     }
  796.     public function removeProfTime(ProfTime $profTime): static
  797.     {
  798.         if ($this->profTimes->removeElement($profTime)) {
  799.             // set the owning side to null (unless already changed)
  800.             if ($profTime->getExam() === $this) {
  801.                 $profTime->setExam(null);
  802.             }
  803.         }
  805.         return $this;
  806.     }
  808.     public function getStartAt(): ?\DateTimeInterface
  809.     {
  810.         return $this->startAt;
  811.     }
  813.     public function setStartAt(?\DateTimeInterface $startAt): static
  814.     {
  815.         $this->startAt = $startAt;
  817.         return $this;
  818.     }
  820.     public function getEndAt(): ?\DateTimeImmutable
  821.     {
  822.         return $this->endAt;
  823.     }
  825.     public function setEndAt(?\DateTimeImmutable $endAt): static
  826.     {
  827.         $this->endAt = $endAt;
  829.         return $this;
  830.     }
  831. }