src/Entity/Student.php line 21

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\StudentRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use App\Entity\Traits\Timestampable;
  11. use JMS\Serializer\Annotation\Groups;
  13. #[ORM\HasLifecycleCallbacks]
  14. #[ORM\Entity(repositoryClass: StudentRepository::class)]
  15. // Ces deux index accélèrent les vérifications faites à chaque ligne d'un import Excel : détection
  16. // de doublon (nom + prénom + date de naissance + école) et unicité du matricule. Sans eux, ces
  17. // recherches font un scan complet de la table student (qui contient TOUS les élèves de TOUTES les
  18. // écoles de la plateforme), ce qui explique un import qui devient de plus en plus lent avec le temps.
  19. #[ORM\Index(name: 'idx_student_dedup', columns: ['school_id', 'last_name', 'first_name', 'born_day'])]
  20. #[ORM\Index(name: 'idx_student_matricule', columns: ['matricule'])]
  21. class Student
  22. {
  23.     use Timestampable;
  24.     #[ORM\Id]
  25.     #[ORM\GeneratedValue]
  26.     #[ORM\Column]
  27.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  28.     private ?int $id = null;
  30.     #[ORM\Column(length: 255,nullable: true)]
  31.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  32.     private ?string $firstName = null;
  34.     #[ORM\Column(length: 255)]
  35.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  36.     private ?string $lastName = null;
  38.     #[ORM\Column(length: 255,nullable: true)]
  39.     #[Groups(['getLate','getAbsence','note','getBulletin','getStudents'])]
  40.     private ?string $matricule = null;
  42.     #[ORM\Column(length: 255, nullable: true)]
  43.     private ?string $bornLocation = null;
  45.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'students')]
  46.     #[Groups(['getStudents'])]
  47.     #[ORM\JoinColumn(nullable: true)]
  48.     private ?User $parent = null;
  50.     // Compte de connexion de l'élève lui-même (userType='student' sur User) — distinct
  51.     // de $parent ci-dessus, qui est le compte du parent/tuteur. Nullable : tous les
  52.     // élèves n'ont pas forcément de compte (créé à la demande par l'admin/scolarité).
  53.     #[ORM\OneToOne(inversedBy: 'studentProfile', cascade: ["persist"])]
  54.     #[ORM\JoinColumn(nullable: true, unique: true)]
  55.     private ?User $account = null;
  57.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: StudentYear::class)]
  58.     private Collection $studentYears;
  60.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Late::class)]
  61.     private Collection $lates;
  63.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Absence::class)]
  64.     private Collection $absences;
  66.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Note::class)]
  67.     private Collection $notes;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $fullName = null;
  72.     #[ORM\ManyToOne(inversedBy: 'studentsEdited', cascade: ["persist"])]
  73.     private ?User $editor = null;
  75.     #[ORM\ManyToOne(inversedBy: 'studentsCreated', cascade: ["persist"])]
  76.     private ?User $author = null;
  77.     
  78.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Punish::class, orphanRemoval: true)]
  79.     private Collection $punishes;
  81.     #[ORM\Column(length: 255, nullable: true)]
  82.     #[Groups(['getStudents'])]
  83.     private ?string $sexe = null;
  85.     #[ORM\ManyToOne(inversedBy: 'students', cascade: ["persist"])]
  86.     #[ORM\JoinColumn(nullable: true)]
  87.     private ?School $school = null;
  89.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineWarning::class)]
  90.     private Collection $disciplineWarnings;
  92.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineBlame::class)]
  93.     private Collection $disciplineBlames;
  95.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineExclusion::class)]
  96.     private Collection $disciplineExclusions;
  98.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineRetained::class)]
  99.     private Collection $disciplineRetaineds;
  101.     #[ORM\OneToOne(mappedBy: 'student', cascade: ['persist', 'remove'])]
  102.     private ?DefinitiveExclusion $definitiveExclusion = null;
  104.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineConcile::class)]
  105.     private Collection $disciplineConciles;
  107.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: PrimaryNote::class)]
  108.     private Collection $primaryNotes;
  110.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplinePunish::class)]
  111.     private Collection $disciplinePunishes;
  112.     
  113.     #[ORM\Column(length: 255, nullable: true)]
  114.     private ?string $picture = null;
  116.     #[ORM\Column(length: 255, nullable: true)]
  117.     private ?string $bornArrondissement = null;
  119.     #[ORM\Column(length: 255, nullable: true)]
  120.     private ?string $bornDepartement = null;
  122.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Blame::class)]
  123.     private Collection $blames;
  125.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Warning::class)]
  126.     private Collection $warnings;
  128.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Retained::class)]
  129.     private Collection $retaineds;
  131.     #[ORM\Column(length: 255, nullable: true)]
  132.     private ?string $father = null;
  134.     #[ORM\Column(length: 255, nullable: true)]
  135.     private ?string $mother = null;
  137.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  138.     private ?\DateTimeInterface $bornDay = null;
  140.     #[ORM\Column(length: 255, nullable: true)]
  141.     private ?string $govMatricule = null;
  143.     public function __construct()
  144.     {
  145.         $this->studentYears = new ArrayCollection();
  146.         $this->lates = new ArrayCollection();
  147.         $this->absences = new ArrayCollection();
  148.         $this->notes = new ArrayCollection();
  149.         $this->punishes = new ArrayCollection();
  150.         $this->disciplineWarnings = new ArrayCollection();
  151.         $this->disciplineBlames = new ArrayCollection();
  152.         $this->disciplineExclusions = new ArrayCollection();
  153.         $this->disciplineRetaineds = new ArrayCollection();
  154.         $this->disciplineConciles = new ArrayCollection();
  155.         $this->primaryNotes = new ArrayCollection();
  156.         $this->disciplinePunishes = new ArrayCollection();
  157.         $this->blames = new ArrayCollection();
  158.         $this->warnings = new ArrayCollection();
  159.         $this->retaineds = new ArrayCollection();
  160.     }
  162.     public function __toString(): string
  163.     {
  164.         return $this->getFullName();
  165.     }
  166.     
  167.     public function getFullName():string
  168.     {
  169.         return  $this->lastName.' '.$this->firstName;
  170.     }
  171.     public function getId(): ?int
  172.     {
  173.         return $this->id;
  174.     }
  176.     public function getFirstName(): ?string
  177.     {
  178.         return $this->firstName;
  179.     }
  181.     public function setFirstName(string $firstName): static
  182.     {
  183.         $this->firstName = $firstName;
  185.         return $this;
  186.     }
  188.     public function getLastName(): ?string
  189.     {
  190.         return $this->lastName;
  191.     }
  193.     public function setLastName(string $lastName): static
  194.     {
  195.         $this->lastName = $lastName;
  197.         return $this;
  198.     }
  200.     public function getMatricule(): ?string
  201.     {
  202.         return $this->matricule;
  203.     }
  205.     public function setMatricule(string $matricule): static
  206.     {
  207.         $this->matricule = $matricule;
  209.         return $this;
  210.     }
  212.     public function getBornLocation(): ?string
  213.     {
  214.         return $this->bornLocation;
  215.     }
  217.     public function setBornLocation(?string $bornLocation): static
  218.     {
  219.         $this->bornLocation = $bornLocation;
  221.         return $this;
  222.     }
  224.     public function getParent(): ?User
  225.     {
  226.         return $this->parent;
  227.     }
  229.     public function setParent(?User $parent): static
  230.     {
  231.         $this->parent = $parent;
  233.         return $this;
  234.     }
  236.     public function getAccount(): ?User
  237.     {
  238.         return $this->account;
  239.     }
  241.     public function setAccount(?User $account): static
  242.     {
  243.         $this->account = $account;
  245.         return $this;
  246.     }
  248.     /**
  249.      * @return Collection<int, StudentYear>
  250.      */
  251.     public function getStudentYears(): Collection
  252.     {
  253.         return $this->studentYears;
  254.     }
  256.     public function addStudentYear(StudentYear $studentYear): static
  257.     {
  258.         if (!$this->studentYears->contains($studentYear)) {
  259.             $this->studentYears->add($studentYear);
  260.             $studentYear->setStudent($this);
  261.         }
  263.         return $this;
  264.     }
  266.     public function removeStudentYear(StudentYear $studentYear): static
  267.     {
  268.         if ($this->studentYears->removeElement($studentYear)) {
  269.             // set the owning side to null (unless already changed)
  270.             if ($studentYear->getStudent() === $this) {
  271.                 $studentYear->setStudent(null);
  272.             }
  273.         }
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection<int, Late>
  280.      */
  281.     public function getLates(): Collection
  282.     {
  283.         return $this->lates;
  284.     }
  286.     public function addLate(Late $late): static
  287.     {
  288.         if (!$this->lates->contains($late)) {
  289.             $this->lates->add($late);
  290.             $late->setStudent($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeLate(Late $late): static
  297.     {
  298.         if ($this->lates->removeElement($late)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($late->getStudent() === $this) {
  301.                 $late->setStudent(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     /**
  309.      * @return Collection<int, Absence>
  310.      */
  311.     public function getAbsences(): Collection
  312.     {
  313.         return $this->absences;
  314.     }
  316.     public function addAbsence(Absence $absence): static
  317.     {
  318.         if (!$this->absences->contains($absence)) {
  319.             $this->absences->add($absence);
  320.             $absence->setStudent($this);
  321.         }
  323.         return $this;
  324.     }
  326.     public function removeAbsence(Absence $absence): static
  327.     {
  328.         if ($this->absences->removeElement($absence)) {
  329.             // set the owning side to null (unless already changed)
  330.             if ($absence->getStudent() === $this) {
  331.                 $absence->setStudent(null);
  332.             }
  333.         }
  335.         return $this;
  336.     }
  338.     /**
  339.      * @return Collection<int, Note>
  340.      */
  341.     public function getNotes(): Collection
  342.     {
  343.         return $this->notes;
  344.     }
  346.     public function addNote(Note $note): static
  347.     {
  348.         if (!$this->notes->contains($note)) {
  349.             $this->notes->add($note);
  350.             $note->setStudent($this);
  351.         }
  353.         return $this;
  354.     }
  356.     public function removeNote(Note $note): static
  357.     {
  358.         if ($this->notes->removeElement($note)) {
  359.             // set the owning side to null (unless already changed)
  360.             if ($note->getStudent() === $this) {
  361.                 $note->setStudent(null);
  362.             }
  363.         }
  365.         return $this;
  366.     }
  368.     public function setFullName(?string $fullName): static
  369.     {
  370.         $this->fullName = $fullName;
  372.         return $this;
  373.     }
  375.     public function getEditor(): ?User
  376.     {
  377.         return $this->editor;
  378.     }
  380.     public function setEditor(?User $editor): static
  381.     {
  382.         $this->editor = $editor;
  383.         return $this;
  384.     }
  386.     /**
  387.      * @return Collection<int, Punish>
  388.      */
  389.     public function getPunishes(): Collection
  390.     {
  391.         return $this->punishes;
  392.     }
  394.     public function addPunishes(Punish $punishDetail): static
  395.     {
  396.         if (!$this->punishes->contains($punishDetail)) {
  397.             $this->punishes->add($punishDetail);
  398.             $punishDetail->setStudent($this);
  399.         }
  401.         return $this;
  402.     }
  403.     
  404.     public function removePunishDetail(Punish $punishes): static
  405.     {
  406.         if ($this->punishes->removeElement($punishes)) {
  407.             // set the owning side to null (unless already changed)
  408.             if ($punishes->getStudent() === $this) {
  409.                 $punishes->setStudent(null);
  410.             }
  411.         }
  413.         return $this;
  414.     }
  416.     public function getAuthor(): ?User
  417.     {
  418.         return $this->author;
  419.     }
  421.     public function setAuthor(?User $author): static
  422.     {
  423.         $this->author = $author;
  425.         return $this;
  426.     }
  428.     public function getSexe(): ?string
  429.     {
  430.         return $this->sexe;
  431.     }
  433.     public function setSexe(string $sexe): static
  434.     {
  435.         $this->sexe = $sexe;
  437.         return $this;
  438.     }
  440.     public function getSchool(): ?School
  441.     {
  442.         return $this->school;
  443.     }
  445.     public function setSchool(?School $school): static
  446.     {
  447.         $this->school = $school;
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection<int, DisciplineWarning>
  454.      */
  455.     public function getDisciplineWarnings(): Collection
  456.     {
  457.         return $this->disciplineWarnings;
  458.     }
  460.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  461.     {
  462.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  463.             $this->disciplineWarnings->add($disciplineWarning);
  464.             $disciplineWarning->setStudent($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  471.     {
  472.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($disciplineWarning->getStudent() === $this) {
  475.                 $disciplineWarning->setStudent(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, DisciplineBlame>
  484.      */
  485.     public function getDisciplineBlames(): Collection
  486.     {
  487.         return $this->disciplineBlames;
  488.     }
  490.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  491.     {
  492.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  493.             $this->disciplineBlames->add($disciplineBlame);
  494.             $disciplineBlame->setStudent($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  501.     {
  502.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($disciplineBlame->getStudent() === $this) {
  505.                 $disciplineBlame->setStudent(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, DisciplineExclusion>
  514.      */
  515.     public function getDisciplineExclusions(): Collection
  516.     {
  517.         return $this->disciplineExclusions;
  518.     }
  520.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  521.     {
  522.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  523.             $this->disciplineExclusions->add($disciplineExclusion);
  524.             $disciplineExclusion->setStudent($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  531.     {
  532.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($disciplineExclusion->getStudent() === $this) {
  535.                 $disciplineExclusion->setStudent(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     /**
  543.      * @return Collection<int, DisciplineRetained>
  544.      */
  545.     public function getDisciplineRetaineds(): Collection
  546.     {
  547.         return $this->disciplineRetaineds;
  548.     }
  550.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  551.     {
  552.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  553.             $this->disciplineRetaineds->add($disciplineRetained);
  554.             $disciplineRetained->setStudent($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  561.     {
  562.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($disciplineRetained->getStudent() === $this) {
  565.                 $disciplineRetained->setStudent(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  572.     public function getDefinitiveExclusion(): ?DefinitiveExclusion
  573.     {
  574.         return $this->definitiveExclusion;
  575.     }
  577.     public function setDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
  578.     {
  579.         // set the owning side of the relation if necessary
  580.         if ($definitiveExclusion->getStudent() !== $this) {
  581.             $definitiveExclusion->setStudent($this);
  582.         }
  584.         $this->definitiveExclusion = $definitiveExclusion;
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, DisciplineConcile>
  591.      */
  592.     public function getDisciplineConciles(): Collection
  593.     {
  594.         return $this->disciplineConciles;
  595.     }
  597.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  598.     {
  599.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  600.             $this->disciplineConciles->add($disciplineConcile);
  601.             $disciplineConcile->setStudent($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  608.     {
  609.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($disciplineConcile->getStudent() === $this) {
  612.                 $disciplineConcile->setStudent(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  619.     /**
  620.      * @return Collection<int, PrimaryNote>
  621.      */
  622.     public function getPrimaryNotes(): Collection
  623.     {
  624.         return $this->primaryNotes;
  625.     }
  627.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  628.     {
  629.         if (!$this->primaryNotes->contains($primaryNote)) {
  630.             $this->primaryNotes->add($primaryNote);
  631.             $primaryNote->setStudent($this);
  632.         }
  634.         return $this;
  635.     }
  637.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  638.     {
  639.         if ($this->primaryNotes->removeElement($primaryNote)) {
  640.             // set the owning side to null (unless already changed)
  641.             if ($primaryNote->getStudent() === $this) {
  642.                 $primaryNote->setStudent(null);
  643.             }
  644.         }
  646.         return $this;
  647.     }
  649.     /**
  650.      * @return Collection<int, DisciplinePunish>
  651.      */
  652.     public function getDisciplinePunishes(): Collection
  653.     {
  654.         return $this->disciplinePunishes;
  655.     }
  657.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  658.     {
  659.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  660.             $this->disciplinePunishes->add($disciplinePunish);
  661.             $disciplinePunish->setStudent($this);
  662.         }
  664.         return $this;
  665.     }
  667.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  668.     {
  669.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  670.             // set the owning side to null (unless already changed)
  671.             if ($disciplinePunish->getStudent() === $this) {
  672.                 $disciplinePunish->setStudent(null);
  673.             }
  674.         }
  676.         return $this;
  677.     }
  678.     
  679.     public function getPicture(): ?string
  680.     {
  681.         return $this->picture;
  682.     }
  684.     public function setPicture(?string $picture): static
  685.     {
  686.         $this->picture = $picture;
  688.         return $this;
  689.     }
  691.     public function getBornArrondissement(): ?string
  692.     {
  693.         return $this->bornArrondissement;
  694.     }
  696.     public function setBornArrondissement(?string $bornArrondissement): static
  697.     {
  698.         $this->bornArrondissement = $bornArrondissement;
  700.         return $this;
  701.     }
  703.     public function getBornDepartement(): ?string
  704.     {
  705.         return $this->bornDepartement;
  706.     }
  708.     public function setBornDepartement(?string $bornDepartement): static
  709.     {
  710.         $this->bornDepartement = $bornDepartement;
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, Blame>
  717.      */
  718.     public function getBlames(): Collection
  719.     {
  720.         return $this->blames;
  721.     }
  723.     public function addBlame(Blame $blame): static
  724.     {
  725.         if (!$this->blames->contains($blame)) {
  726.             $this->blames->add($blame);
  727.             $blame->setStudent($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removeBlame(Blame $blame): static
  734.     {
  735.         if ($this->blames->removeElement($blame)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($blame->getStudent() === $this) {
  738.                 $blame->setStudent(null);
  739.             }
  740.         }
  742.         return $this;
  743.     }
  745.     /**
  746.      * @return Collection<int, Warning>
  747.      */
  748.     public function getWarnings(): Collection
  749.     {
  750.         return $this->warnings;
  751.     }
  753.     public function addWarning(Warning $warning): static
  754.     {
  755.         if (!$this->warnings->contains($warning)) {
  756.             $this->warnings->add($warning);
  757.             $warning->setStudent($this);
  758.         }
  760.         return $this;
  761.     }
  763.     public function removeWarning(Warning $warning): static
  764.     {
  765.         if ($this->warnings->removeElement($warning)) {
  766.             // set the owning side to null (unless already changed)
  767.             if ($warning->getStudent() === $this) {
  768.                 $warning->setStudent(null);
  769.             }
  770.         }
  772.         return $this;
  773.     }
  775.     /**
  776.      * @return Collection<int, Retained>
  777.      */
  778.     public function getRetaineds(): Collection
  779.     {
  780.         return $this->retaineds;
  781.     }
  783.     public function addRetained(Retained $retained): static
  784.     {
  785.         if (!$this->retaineds->contains($retained)) {
  786.             $this->retaineds->add($retained);
  787.             $retained->setStudent($this);
  788.         }
  790.         return $this;
  791.     }
  793.     public function removeRetained(Retained $retained): static
  794.     {
  795.         if ($this->retaineds->removeElement($retained)) {
  796.             // set the owning side to null (unless already changed)
  797.             if ($retained->getStudent() === $this) {
  798.                 $retained->setStudent(null);
  799.             }
  800.         }
  802.         return $this;
  803.     }
  805.     public function getFather(): ?string
  806.     {
  807.         return $this->father;
  808.     }
  810.     public function setFather(?string $father): static
  811.     {
  812.         $this->father = $father;
  814.         return $this;
  815.     }
  817.     public function getMother(): ?string
  818.     {
  819.         return $this->mother;
  820.     }
  822.     public function setMother(?string $mother): static
  823.     {
  824.         $this->mother = $mother;
  826.         return $this;
  827.     }
  829.     public function getBornDay(): ?\DateTimeInterface
  830.     {
  831.         return $this->bornDay;
  832.     }
  834.     public function setBornDay(?\DateTimeInterface $bornDay): static
  835.     {
  836.         $this->bornDay = $bornDay;
  838.         return $this;
  839.     }
  841.     public function getGovMatricule(): ?string
  842.     {
  843.         return $this->govMatricule;
  844.     }
  846.     public function setGovMatricule(?string $govMatricule): static
  847.     {
  848.         $this->govMatricule = $govMatricule;
  850.         return $this;
  851.     }
  852. }