src/Entity/Student.php line 15

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. class Student
  16. {
  17.     use Timestampable;
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  22.     private ?int $id = null;
  24.     #[ORM\Column(length: 255)]
  25.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  26.     private ?string $firstName = null;
  28.     #[ORM\Column(length: 255)]
  29.     #[Groups(['getLate','getAbsence','note','getBulletin','getPunish','getStudents','getExamStudent'])]
  30.     private ?string $lastName = null;
  32.     #[ORM\Column(length: 255,nullable: true)]
  33.     #[Groups(['getLate','getAbsence','note','getBulletin','getStudents'])]
  34.     private ?string $matricule = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     private ?string $bornLocation = null;
  39.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'students')]
  40.     #[Groups(['getStudents'])]
  41.     #[ORM\JoinColumn(nullable: true)]
  42.     private ?User $parent = null;
  44.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: StudentYear::class)]
  45.     private Collection $studentYears;
  47.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Late::class)]
  48.     private Collection $lates;
  50.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Absence::class)]
  51.     private Collection $absences;
  53.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Note::class)]
  54.     private Collection $notes;
  56.     #[ORM\Column(length: 255, nullable: true)]
  57.     private ?string $fullName = null;
  59.     #[ORM\ManyToOne(inversedBy: 'studentsEdited', cascade: ["persist"])]
  60.     private ?User $editor = null;
  62.     #[ORM\ManyToOne(inversedBy: 'studentsCreated', cascade: ["persist"])]
  63.     private ?User $author = null;
  64.     
  65.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Punish::class, orphanRemoval: true)]
  66.     private Collection $punishes;
  68.     #[ORM\Column(length: 255)]
  69.     #[Groups(['getStudents'])]
  70.     private ?string $sexe = null;
  72.     #[ORM\ManyToOne(inversedBy: 'students', cascade: ["persist"])]
  73.     #[ORM\JoinColumn(nullable: true)]
  74.     private ?School $school = null;
  76.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineWarning::class)]
  77.     private Collection $disciplineWarnings;
  79.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineBlame::class)]
  80.     private Collection $disciplineBlames;
  82.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineExclusion::class)]
  83.     private Collection $disciplineExclusions;
  85.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineRetained::class)]
  86.     private Collection $disciplineRetaineds;
  88.     #[ORM\OneToOne(mappedBy: 'student', cascade: ['persist', 'remove'])]
  89.     private ?DefinitiveExclusion $definitiveExclusion = null;
  91.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineConcile::class)]
  92.     private Collection $disciplineConciles;
  94.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: PrimaryNote::class)]
  95.     private Collection $primaryNotes;
  97.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplinePunish::class)]
  98.     private Collection $disciplinePunishes;
  99.     
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     private ?string $picture = null;
  103.     #[ORM\Column(length: 255, nullable: true)]
  104.     private ?string $bornArrondissement = null;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     private ?string $bornDepartement = null;
  109.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Blame::class)]
  110.     private Collection $blames;
  112.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Warning::class)]
  113.     private Collection $warnings;
  115.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Retained::class)]
  116.     private Collection $retaineds;
  118.     #[ORM\Column(length: 255, nullable: true)]
  119.     private ?string $father = null;
  121.     #[ORM\Column(length: 255, nullable: true)]
  122.     private ?string $mother = null;
  124.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  125.     private ?\DateTimeInterface $bornDay = null;
  127.     #[ORM\Column(length: 255, nullable: true)]
  128.     private ?string $govMatricule = null;
  130.     public function __construct()
  131.     {
  132.         $this->studentYears = new ArrayCollection();
  133.         $this->lates = new ArrayCollection();
  134.         $this->absences = new ArrayCollection();
  135.         $this->notes = new ArrayCollection();
  136.         $this->punishes = new ArrayCollection();
  137.         $this->disciplineWarnings = new ArrayCollection();
  138.         $this->disciplineBlames = new ArrayCollection();
  139.         $this->disciplineExclusions = new ArrayCollection();
  140.         $this->disciplineRetaineds = new ArrayCollection();
  141.         $this->disciplineConciles = new ArrayCollection();
  142.         $this->primaryNotes = new ArrayCollection();
  143.         $this->disciplinePunishes = new ArrayCollection();
  144.         $this->blames = new ArrayCollection();
  145.         $this->warnings = new ArrayCollection();
  146.         $this->retaineds = new ArrayCollection();
  147.     }
  149.     public function __toString(): string
  150.     {
  151.         return $this->getFullName();
  152.     }
  153.     
  154.     public function getFullName():string
  155.     {
  156.         return  $this->lastName.' '.$this->firstName;
  157.     }
  158.     public function getId(): ?int
  159.     {
  160.         return $this->id;
  161.     }
  163.     public function getFirstName(): ?string
  164.     {
  165.         return $this->firstName;
  166.     }
  168.     public function setFirstName(string $firstName): static
  169.     {
  170.         $this->firstName = $firstName;
  172.         return $this;
  173.     }
  175.     public function getLastName(): ?string
  176.     {
  177.         return $this->lastName;
  178.     }
  180.     public function setLastName(string $lastName): static
  181.     {
  182.         $this->lastName = $lastName;
  184.         return $this;
  185.     }
  187.     public function getMatricule(): ?string
  188.     {
  189.         return $this->matricule;
  190.     }
  192.     public function setMatricule(string $matricule): static
  193.     {
  194.         $this->matricule = $matricule;
  196.         return $this;
  197.     }
  199.     public function getBornLocation(): ?string
  200.     {
  201.         return $this->bornLocation;
  202.     }
  204.     public function setBornLocation(?string $bornLocation): static
  205.     {
  206.         $this->bornLocation = $bornLocation;
  208.         return $this;
  209.     }
  211.     public function getParent(): ?User
  212.     {
  213.         return $this->parent;
  214.     }
  216.     public function setParent(?User $parent): static
  217.     {
  218.         $this->parent = $parent;
  220.         return $this;
  221.     }
  223.     /**
  224.      * @return Collection<int, StudentYear>
  225.      */
  226.     public function getStudentYears(): Collection
  227.     {
  228.         return $this->studentYears;
  229.     }
  231.     public function addStudentYear(StudentYear $studentYear): static
  232.     {
  233.         if (!$this->studentYears->contains($studentYear)) {
  234.             $this->studentYears->add($studentYear);
  235.             $studentYear->setStudent($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function removeStudentYear(StudentYear $studentYear): static
  242.     {
  243.         if ($this->studentYears->removeElement($studentYear)) {
  244.             // set the owning side to null (unless already changed)
  245.             if ($studentYear->getStudent() === $this) {
  246.                 $studentYear->setStudent(null);
  247.             }
  248.         }
  250.         return $this;
  251.     }
  253.     /**
  254.      * @return Collection<int, Late>
  255.      */
  256.     public function getLates(): Collection
  257.     {
  258.         return $this->lates;
  259.     }
  261.     public function addLate(Late $late): static
  262.     {
  263.         if (!$this->lates->contains($late)) {
  264.             $this->lates->add($late);
  265.             $late->setStudent($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeLate(Late $late): static
  272.     {
  273.         if ($this->lates->removeElement($late)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($late->getStudent() === $this) {
  276.                 $late->setStudent(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.     /**
  284.      * @return Collection<int, Absence>
  285.      */
  286.     public function getAbsences(): Collection
  287.     {
  288.         return $this->absences;
  289.     }
  291.     public function addAbsence(Absence $absence): static
  292.     {
  293.         if (!$this->absences->contains($absence)) {
  294.             $this->absences->add($absence);
  295.             $absence->setStudent($this);
  296.         }
  298.         return $this;
  299.     }
  301.     public function removeAbsence(Absence $absence): static
  302.     {
  303.         if ($this->absences->removeElement($absence)) {
  304.             // set the owning side to null (unless already changed)
  305.             if ($absence->getStudent() === $this) {
  306.                 $absence->setStudent(null);
  307.             }
  308.         }
  310.         return $this;
  311.     }
  313.     /**
  314.      * @return Collection<int, Note>
  315.      */
  316.     public function getNotes(): Collection
  317.     {
  318.         return $this->notes;
  319.     }
  321.     public function addNote(Note $note): static
  322.     {
  323.         if (!$this->notes->contains($note)) {
  324.             $this->notes->add($note);
  325.             $note->setStudent($this);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeNote(Note $note): static
  332.     {
  333.         if ($this->notes->removeElement($note)) {
  334.             // set the owning side to null (unless already changed)
  335.             if ($note->getStudent() === $this) {
  336.                 $note->setStudent(null);
  337.             }
  338.         }
  340.         return $this;
  341.     }
  343.     public function setFullName(?string $fullName): static
  344.     {
  345.         $this->fullName = $fullName;
  347.         return $this;
  348.     }
  350.     public function getEditor(): ?User
  351.     {
  352.         return $this->editor;
  353.     }
  355.     public function setEditor(?User $editor): static
  356.     {
  357.         $this->editor = $editor;
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, Punish>
  363.      */
  364.     public function getPunishes(): Collection
  365.     {
  366.         return $this->punishes;
  367.     }
  369.     public function addPunishes(Punish $punishDetail): static
  370.     {
  371.         if (!$this->punishes->contains($punishDetail)) {
  372.             $this->punishes->add($punishDetail);
  373.             $punishDetail->setStudent($this);
  374.         }
  376.         return $this;
  377.     }
  378.     
  379.     public function removePunishDetail(Punish $punishes): static
  380.     {
  381.         if ($this->punishes->removeElement($punishes)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($punishes->getStudent() === $this) {
  384.                 $punishes->setStudent(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     public function getAuthor(): ?User
  392.     {
  393.         return $this->author;
  394.     }
  396.     public function setAuthor(?User $author): static
  397.     {
  398.         $this->author = $author;
  400.         return $this;
  401.     }
  403.     public function getSexe(): ?string
  404.     {
  405.         return $this->sexe;
  406.     }
  408.     public function setSexe(string $sexe): static
  409.     {
  410.         $this->sexe = $sexe;
  412.         return $this;
  413.     }
  415.     public function getSchool(): ?School
  416.     {
  417.         return $this->school;
  418.     }
  420.     public function setSchool(?School $school): static
  421.     {
  422.         $this->school = $school;
  424.         return $this;
  425.     }
  427.     /**
  428.      * @return Collection<int, DisciplineWarning>
  429.      */
  430.     public function getDisciplineWarnings(): Collection
  431.     {
  432.         return $this->disciplineWarnings;
  433.     }
  435.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  436.     {
  437.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  438.             $this->disciplineWarnings->add($disciplineWarning);
  439.             $disciplineWarning->setStudent($this);
  440.         }
  442.         return $this;
  443.     }
  445.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  446.     {
  447.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  448.             // set the owning side to null (unless already changed)
  449.             if ($disciplineWarning->getStudent() === $this) {
  450.                 $disciplineWarning->setStudent(null);
  451.             }
  452.         }
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection<int, DisciplineBlame>
  459.      */
  460.     public function getDisciplineBlames(): Collection
  461.     {
  462.         return $this->disciplineBlames;
  463.     }
  465.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  466.     {
  467.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  468.             $this->disciplineBlames->add($disciplineBlame);
  469.             $disciplineBlame->setStudent($this);
  470.         }
  472.         return $this;
  473.     }
  475.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  476.     {
  477.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  478.             // set the owning side to null (unless already changed)
  479.             if ($disciplineBlame->getStudent() === $this) {
  480.                 $disciplineBlame->setStudent(null);
  481.             }
  482.         }
  484.         return $this;
  485.     }
  487.     /**
  488.      * @return Collection<int, DisciplineExclusion>
  489.      */
  490.     public function getDisciplineExclusions(): Collection
  491.     {
  492.         return $this->disciplineExclusions;
  493.     }
  495.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  496.     {
  497.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  498.             $this->disciplineExclusions->add($disciplineExclusion);
  499.             $disciplineExclusion->setStudent($this);
  500.         }
  502.         return $this;
  503.     }
  505.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  506.     {
  507.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  508.             // set the owning side to null (unless already changed)
  509.             if ($disciplineExclusion->getStudent() === $this) {
  510.                 $disciplineExclusion->setStudent(null);
  511.             }
  512.         }
  514.         return $this;
  515.     }
  517.     /**
  518.      * @return Collection<int, DisciplineRetained>
  519.      */
  520.     public function getDisciplineRetaineds(): Collection
  521.     {
  522.         return $this->disciplineRetaineds;
  523.     }
  525.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  526.     {
  527.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  528.             $this->disciplineRetaineds->add($disciplineRetained);
  529.             $disciplineRetained->setStudent($this);
  530.         }
  532.         return $this;
  533.     }
  535.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  536.     {
  537.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  538.             // set the owning side to null (unless already changed)
  539.             if ($disciplineRetained->getStudent() === $this) {
  540.                 $disciplineRetained->setStudent(null);
  541.             }
  542.         }
  544.         return $this;
  545.     }
  547.     public function getDefinitiveExclusion(): ?DefinitiveExclusion
  548.     {
  549.         return $this->definitiveExclusion;
  550.     }
  552.     public function setDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
  553.     {
  554.         // set the owning side of the relation if necessary
  555.         if ($definitiveExclusion->getStudent() !== $this) {
  556.             $definitiveExclusion->setStudent($this);
  557.         }
  559.         $this->definitiveExclusion = $definitiveExclusion;
  561.         return $this;
  562.     }
  564.     /**
  565.      * @return Collection<int, DisciplineConcile>
  566.      */
  567.     public function getDisciplineConciles(): Collection
  568.     {
  569.         return $this->disciplineConciles;
  570.     }
  572.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  573.     {
  574.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  575.             $this->disciplineConciles->add($disciplineConcile);
  576.             $disciplineConcile->setStudent($this);
  577.         }
  579.         return $this;
  580.     }
  582.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  583.     {
  584.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  585.             // set the owning side to null (unless already changed)
  586.             if ($disciplineConcile->getStudent() === $this) {
  587.                 $disciplineConcile->setStudent(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection<int, PrimaryNote>
  596.      */
  597.     public function getPrimaryNotes(): Collection
  598.     {
  599.         return $this->primaryNotes;
  600.     }
  602.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  603.     {
  604.         if (!$this->primaryNotes->contains($primaryNote)) {
  605.             $this->primaryNotes->add($primaryNote);
  606.             $primaryNote->setStudent($this);
  607.         }
  609.         return $this;
  610.     }
  612.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  613.     {
  614.         if ($this->primaryNotes->removeElement($primaryNote)) {
  615.             // set the owning side to null (unless already changed)
  616.             if ($primaryNote->getStudent() === $this) {
  617.                 $primaryNote->setStudent(null);
  618.             }
  619.         }
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return Collection<int, DisciplinePunish>
  626.      */
  627.     public function getDisciplinePunishes(): Collection
  628.     {
  629.         return $this->disciplinePunishes;
  630.     }
  632.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  633.     {
  634.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  635.             $this->disciplinePunishes->add($disciplinePunish);
  636.             $disciplinePunish->setStudent($this);
  637.         }
  639.         return $this;
  640.     }
  642.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  643.     {
  644.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  645.             // set the owning side to null (unless already changed)
  646.             if ($disciplinePunish->getStudent() === $this) {
  647.                 $disciplinePunish->setStudent(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  653.     
  654.     public function getPicture(): ?string
  655.     {
  656.         return $this->picture;
  657.     }
  659.     public function setPicture(?string $picture): static
  660.     {
  661.         $this->picture = $picture;
  663.         return $this;
  664.     }
  666.     public function getBornArrondissement(): ?string
  667.     {
  668.         return $this->bornArrondissement;
  669.     }
  671.     public function setBornArrondissement(?string $bornArrondissement): static
  672.     {
  673.         $this->bornArrondissement = $bornArrondissement;
  675.         return $this;
  676.     }
  678.     public function getBornDepartement(): ?string
  679.     {
  680.         return $this->bornDepartement;
  681.     }
  683.     public function setBornDepartement(?string $bornDepartement): static
  684.     {
  685.         $this->bornDepartement = $bornDepartement;
  687.         return $this;
  688.     }
  690.     /**
  691.      * @return Collection<int, Blame>
  692.      */
  693.     public function getBlames(): Collection
  694.     {
  695.         return $this->blames;
  696.     }
  698.     public function addBlame(Blame $blame): static
  699.     {
  700.         if (!$this->blames->contains($blame)) {
  701.             $this->blames->add($blame);
  702.             $blame->setStudent($this);
  703.         }
  705.         return $this;
  706.     }
  708.     public function removeBlame(Blame $blame): static
  709.     {
  710.         if ($this->blames->removeElement($blame)) {
  711.             // set the owning side to null (unless already changed)
  712.             if ($blame->getStudent() === $this) {
  713.                 $blame->setStudent(null);
  714.             }
  715.         }
  717.         return $this;
  718.     }
  720.     /**
  721.      * @return Collection<int, Warning>
  722.      */
  723.     public function getWarnings(): Collection
  724.     {
  725.         return $this->warnings;
  726.     }
  728.     public function addWarning(Warning $warning): static
  729.     {
  730.         if (!$this->warnings->contains($warning)) {
  731.             $this->warnings->add($warning);
  732.             $warning->setStudent($this);
  733.         }
  735.         return $this;
  736.     }
  738.     public function removeWarning(Warning $warning): static
  739.     {
  740.         if ($this->warnings->removeElement($warning)) {
  741.             // set the owning side to null (unless already changed)
  742.             if ($warning->getStudent() === $this) {
  743.                 $warning->setStudent(null);
  744.             }
  745.         }
  747.         return $this;
  748.     }
  750.     /**
  751.      * @return Collection<int, Retained>
  752.      */
  753.     public function getRetaineds(): Collection
  754.     {
  755.         return $this->retaineds;
  756.     }
  758.     public function addRetained(Retained $retained): static
  759.     {
  760.         if (!$this->retaineds->contains($retained)) {
  761.             $this->retaineds->add($retained);
  762.             $retained->setStudent($this);
  763.         }
  765.         return $this;
  766.     }
  768.     public function removeRetained(Retained $retained): static
  769.     {
  770.         if ($this->retaineds->removeElement($retained)) {
  771.             // set the owning side to null (unless already changed)
  772.             if ($retained->getStudent() === $this) {
  773.                 $retained->setStudent(null);
  774.             }
  775.         }
  777.         return $this;
  778.     }
  780.     public function getFather(): ?string
  781.     {
  782.         return $this->father;
  783.     }
  785.     public function setFather(?string $father): static
  786.     {
  787.         $this->father = $father;
  789.         return $this;
  790.     }
  792.     public function getMother(): ?string
  793.     {
  794.         return $this->mother;
  795.     }
  797.     public function setMother(?string $mother): static
  798.     {
  799.         $this->mother = $mother;
  801.         return $this;
  802.     }
  804.     public function getBornDay(): ?\DateTimeInterface
  805.     {
  806.         return $this->bornDay;
  807.     }
  809.     public function setBornDay(?\DateTimeInterface $bornDay): static
  810.     {
  811.         $this->bornDay = $bornDay;
  813.         return $this;
  814.     }
  816.     public function getGovMatricule(): ?string
  817.     {
  818.         return $this->govMatricule;
  819.     }
  821.     public function setGovMatricule(?string $govMatricule): static
  822.     {
  823.         $this->govMatricule = $govMatricule;
  825.         return $this;
  826.     }
  827. }