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.     private ?User $parent = null;
  43.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: StudentYear::class, orphanRemoval: true)]
  44.     private Collection $studentYears;
  46.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Late::class, orphanRemoval: true)]
  47.     private Collection $lates;
  49.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Absence::class, orphanRemoval: true)]
  50.     private Collection $absences;
  52.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Note::class, orphanRemoval: true)]
  53.     private Collection $notes;
  55.     #[ORM\Column(length: 255, nullable: true)]
  56.     private ?string $fullName = null;
  58.     #[ORM\ManyToOne(inversedBy: 'studentsEdited', cascade: ["persist"])]
  59.     private ?User $editor = null;
  61.     #[ORM\ManyToOne(inversedBy: 'studentsCreated', cascade: ["persist"])]
  62.     private ?User $author = null;
  63.     
  64.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Punish::class, orphanRemoval: true)]
  65.     private Collection $punishes;
  67.     #[ORM\Column(length: 255)]
  68.     #[Groups(['getStudents'])]
  69.     private ?string $sexe = null;
  71.     #[ORM\ManyToOne(inversedBy: 'students', cascade: ["persist"])]
  72.     private ?School $school = null;
  74.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineWarning::class , orphanRemoval: true)]
  75.     private Collection $disciplineWarnings;
  77.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineBlame::class , orphanRemoval: true)]
  78.     private Collection $disciplineBlames;
  80.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineExclusion::class , orphanRemoval: true)]
  81.     private Collection $disciplineExclusions;
  83.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineRetained::class , orphanRemoval: true)]
  84.     private Collection $disciplineRetaineds;
  86.     #[ORM\OneToOne(mappedBy: 'student', cascade: ['persist', 'remove'])]
  87.     private ?DefinitiveExclusion $definitiveExclusion = null;
  89.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplineConcile::class , orphanRemoval: true)]
  90.     private Collection $disciplineConciles;
  92.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: PrimaryNote::class , orphanRemoval: true)]
  93.     private Collection $primaryNotes;
  95.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: DisciplinePunish::class , orphanRemoval: true)]
  96.     private Collection $disciplinePunishes;
  97.     
  98.     #[ORM\Column(length: 255, nullable: true)]
  99.     private ?string $picture = null;
  101.     #[ORM\Column(length: 255, nullable: true)]
  102.     private ?string $bornArrondissement = null;
  104.     #[ORM\Column(length: 255, nullable: true)]
  105.     private ?string $bornDepartement = null;
  107.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Blame::class , orphanRemoval: true)]
  108.     private Collection $blames;
  110.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Warning::class , orphanRemoval: true)]
  111.     private Collection $warnings;
  113.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: Retained::class , orphanRemoval: true)]
  114.     private Collection $retaineds;
  116.     #[ORM\Column(length: 255, nullable: true)]
  117.     private ?string $father = null;
  119.     #[ORM\Column(length: 255, nullable: true)]
  120.     private ?string $mother = null;
  122.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  123.     private ?\DateTimeInterface $bornDay = null;
  125.     public function __construct()
  126.     {
  127.         $this->studentYears = new ArrayCollection();
  128.         $this->lates = new ArrayCollection();
  129.         $this->absences = new ArrayCollection();
  130.         $this->notes = new ArrayCollection();
  131.         $this->punishes = new ArrayCollection();
  132.         $this->disciplineWarnings = new ArrayCollection();
  133.         $this->disciplineBlames = new ArrayCollection();
  134.         $this->disciplineExclusions = new ArrayCollection();
  135.         $this->disciplineRetaineds = new ArrayCollection();
  136.         $this->disciplineConciles = new ArrayCollection();
  137.         $this->primaryNotes = new ArrayCollection();
  138.         $this->disciplinePunishes = new ArrayCollection();
  139.         $this->blames = new ArrayCollection();
  140.         $this->warnings = new ArrayCollection();
  141.         $this->retaineds = new ArrayCollection();
  142.     }
  144.     public function __toString(): string
  145.     {
  146.         return $this->getFullName();
  147.     }
  148.     
  149.     public function getFullName():string
  150.     {
  151.         return  $this->lastName.' '.$this->firstName;
  152.     }
  153.     public function getId(): ?int
  154.     {
  155.         return $this->id;
  156.     }
  158.     public function getFirstName(): ?string
  159.     {
  160.         return $this->firstName;
  161.     }
  163.     public function setFirstName(string $firstName): static
  164.     {
  165.         $this->firstName = $firstName;
  167.         return $this;
  168.     }
  170.     public function getLastName(): ?string
  171.     {
  172.         return $this->lastName;
  173.     }
  175.     public function setLastName(string $lastName): static
  176.     {
  177.         $this->lastName = $lastName;
  179.         return $this;
  180.     }
  182.     public function getMatricule(): ?string
  183.     {
  184.         return $this->matricule;
  185.     }
  187.     public function setMatricule(string $matricule): static
  188.     {
  189.         $this->matricule = $matricule;
  191.         return $this;
  192.     }
  194.     public function getBornLocation(): ?string
  195.     {
  196.         return $this->bornLocation;
  197.     }
  199.     public function setBornLocation(?string $bornLocation): static
  200.     {
  201.         $this->bornLocation = $bornLocation;
  203.         return $this;
  204.     }
  206.     public function getParent(): ?User
  207.     {
  208.         return $this->parent;
  209.     }
  211.     public function setParent(?User $parent): static
  212.     {
  213.         $this->parent = $parent;
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return Collection<int, StudentYear>
  220.      */
  221.     public function getStudentYears(): Collection
  222.     {
  223.         return $this->studentYears;
  224.     }
  226.     public function addStudentYear(StudentYear $studentYear): static
  227.     {
  228.         if (!$this->studentYears->contains($studentYear)) {
  229.             $this->studentYears->add($studentYear);
  230.             $studentYear->setStudent($this);
  231.         }
  233.         return $this;
  234.     }
  236.     public function removeStudentYear(StudentYear $studentYear): static
  237.     {
  238.         if ($this->studentYears->removeElement($studentYear)) {
  239.             // set the owning side to null (unless already changed)
  240.             if ($studentYear->getStudent() === $this) {
  241.                 $studentYear->setStudent(null);
  242.             }
  243.         }
  245.         return $this;
  246.     }
  248.     /**
  249.      * @return Collection<int, Late>
  250.      */
  251.     public function getLates(): Collection
  252.     {
  253.         return $this->lates;
  254.     }
  256.     public function addLate(Late $late): static
  257.     {
  258.         if (!$this->lates->contains($late)) {
  259.             $this->lates->add($late);
  260.             $late->setStudent($this);
  261.         }
  263.         return $this;
  264.     }
  266.     public function removeLate(Late $late): static
  267.     {
  268.         if ($this->lates->removeElement($late)) {
  269.             // set the owning side to null (unless already changed)
  270.             if ($late->getStudent() === $this) {
  271.                 $late->setStudent(null);
  272.             }
  273.         }
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection<int, Absence>
  280.      */
  281.     public function getAbsences(): Collection
  282.     {
  283.         return $this->absences;
  284.     }
  286.     public function addAbsence(Absence $absence): static
  287.     {
  288.         if (!$this->absences->contains($absence)) {
  289.             $this->absences->add($absence);
  290.             $absence->setStudent($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeAbsence(Absence $absence): static
  297.     {
  298.         if ($this->absences->removeElement($absence)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($absence->getStudent() === $this) {
  301.                 $absence->setStudent(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     /**
  309.      * @return Collection<int, Note>
  310.      */
  311.     public function getNotes(): Collection
  312.     {
  313.         return $this->notes;
  314.     }
  316.     public function addNote(Note $note): static
  317.     {
  318.         if (!$this->notes->contains($note)) {
  319.             $this->notes->add($note);
  320.             $note->setStudent($this);
  321.         }
  323.         return $this;
  324.     }
  326.     public function removeNote(Note $note): static
  327.     {
  328.         if ($this->notes->removeElement($note)) {
  329.             // set the owning side to null (unless already changed)
  330.             if ($note->getStudent() === $this) {
  331.                 $note->setStudent(null);
  332.             }
  333.         }
  335.         return $this;
  336.     }
  338.     public function setFullName(?string $fullName): static
  339.     {
  340.         $this->fullName = $fullName;
  342.         return $this;
  343.     }
  345.     public function getEditor(): ?User
  346.     {
  347.         return $this->editor;
  348.     }
  350.     public function setEditor(?User $editor): static
  351.     {
  352.         $this->editor = $editor;
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection<int, Punish>
  358.      */
  359.     public function getPunishes(): Collection
  360.     {
  361.         return $this->punishes;
  362.     }
  364.     public function addPunishes(Punish $punishDetail): static
  365.     {
  366.         if (!$this->punishes->contains($punishDetail)) {
  367.             $this->punishes->add($punishDetail);
  368.             $punishDetail->setStudent($this);
  369.         }
  371.         return $this;
  372.     }
  373.     
  374.     public function removePunishDetail(Punish $punishes): static
  375.     {
  376.         if ($this->punishes->removeElement($punishes)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($punishes->getStudent() === $this) {
  379.                 $punishes->setStudent(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     public function getAuthor(): ?User
  387.     {
  388.         return $this->author;
  389.     }
  391.     public function setAuthor(?User $author): static
  392.     {
  393.         $this->author = $author;
  395.         return $this;
  396.     }
  398.     public function getSexe(): ?string
  399.     {
  400.         return $this->sexe;
  401.     }
  403.     public function setSexe(string $sexe): static
  404.     {
  405.         $this->sexe = $sexe;
  407.         return $this;
  408.     }
  410.     public function getSchool(): ?School
  411.     {
  412.         return $this->school;
  413.     }
  415.     public function setSchool(?School $school): static
  416.     {
  417.         $this->school = $school;
  419.         return $this;
  420.     }
  422.     /**
  423.      * @return Collection<int, DisciplineWarning>
  424.      */
  425.     public function getDisciplineWarnings(): Collection
  426.     {
  427.         return $this->disciplineWarnings;
  428.     }
  430.     public function addDisciplineWarning(DisciplineWarning $disciplineWarning): static
  431.     {
  432.         if (!$this->disciplineWarnings->contains($disciplineWarning)) {
  433.             $this->disciplineWarnings->add($disciplineWarning);
  434.             $disciplineWarning->setStudent($this);
  435.         }
  437.         return $this;
  438.     }
  440.     public function removeDisciplineWarning(DisciplineWarning $disciplineWarning): static
  441.     {
  442.         if ($this->disciplineWarnings->removeElement($disciplineWarning)) {
  443.             // set the owning side to null (unless already changed)
  444.             if ($disciplineWarning->getStudent() === $this) {
  445.                 $disciplineWarning->setStudent(null);
  446.             }
  447.         }
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection<int, DisciplineBlame>
  454.      */
  455.     public function getDisciplineBlames(): Collection
  456.     {
  457.         return $this->disciplineBlames;
  458.     }
  460.     public function addDisciplineBlame(DisciplineBlame $disciplineBlame): static
  461.     {
  462.         if (!$this->disciplineBlames->contains($disciplineBlame)) {
  463.             $this->disciplineBlames->add($disciplineBlame);
  464.             $disciplineBlame->setStudent($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeDisciplineBlame(DisciplineBlame $disciplineBlame): static
  471.     {
  472.         if ($this->disciplineBlames->removeElement($disciplineBlame)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($disciplineBlame->getStudent() === $this) {
  475.                 $disciplineBlame->setStudent(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, DisciplineExclusion>
  484.      */
  485.     public function getDisciplineExclusions(): Collection
  486.     {
  487.         return $this->disciplineExclusions;
  488.     }
  490.     public function addDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  491.     {
  492.         if (!$this->disciplineExclusions->contains($disciplineExclusion)) {
  493.             $this->disciplineExclusions->add($disciplineExclusion);
  494.             $disciplineExclusion->setStudent($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeDisciplineExclusion(DisciplineExclusion $disciplineExclusion): static
  501.     {
  502.         if ($this->disciplineExclusions->removeElement($disciplineExclusion)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($disciplineExclusion->getStudent() === $this) {
  505.                 $disciplineExclusion->setStudent(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, DisciplineRetained>
  514.      */
  515.     public function getDisciplineRetaineds(): Collection
  516.     {
  517.         return $this->disciplineRetaineds;
  518.     }
  520.     public function addDisciplineRetained(DisciplineRetained $disciplineRetained): static
  521.     {
  522.         if (!$this->disciplineRetaineds->contains($disciplineRetained)) {
  523.             $this->disciplineRetaineds->add($disciplineRetained);
  524.             $disciplineRetained->setStudent($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeDisciplineRetained(DisciplineRetained $disciplineRetained): static
  531.     {
  532.         if ($this->disciplineRetaineds->removeElement($disciplineRetained)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($disciplineRetained->getStudent() === $this) {
  535.                 $disciplineRetained->setStudent(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     public function getDefinitiveExclusion(): ?DefinitiveExclusion
  543.     {
  544.         return $this->definitiveExclusion;
  545.     }
  547.     public function setDefinitiveExclusion(DefinitiveExclusion $definitiveExclusion): static
  548.     {
  549.         // set the owning side of the relation if necessary
  550.         if ($definitiveExclusion->getStudent() !== $this) {
  551.             $definitiveExclusion->setStudent($this);
  552.         }
  554.         $this->definitiveExclusion = $definitiveExclusion;
  556.         return $this;
  557.     }
  559.     /**
  560.      * @return Collection<int, DisciplineConcile>
  561.      */
  562.     public function getDisciplineConciles(): Collection
  563.     {
  564.         return $this->disciplineConciles;
  565.     }
  567.     public function addDisciplineConcile(DisciplineConcile $disciplineConcile): static
  568.     {
  569.         if (!$this->disciplineConciles->contains($disciplineConcile)) {
  570.             $this->disciplineConciles->add($disciplineConcile);
  571.             $disciplineConcile->setStudent($this);
  572.         }
  574.         return $this;
  575.     }
  577.     public function removeDisciplineConcile(DisciplineConcile $disciplineConcile): static
  578.     {
  579.         if ($this->disciplineConciles->removeElement($disciplineConcile)) {
  580.             // set the owning side to null (unless already changed)
  581.             if ($disciplineConcile->getStudent() === $this) {
  582.                 $disciplineConcile->setStudent(null);
  583.             }
  584.         }
  586.         return $this;
  587.     }
  589.     /**
  590.      * @return Collection<int, PrimaryNote>
  591.      */
  592.     public function getPrimaryNotes(): Collection
  593.     {
  594.         return $this->primaryNotes;
  595.     }
  597.     public function addPrimaryNote(PrimaryNote $primaryNote): static
  598.     {
  599.         if (!$this->primaryNotes->contains($primaryNote)) {
  600.             $this->primaryNotes->add($primaryNote);
  601.             $primaryNote->setStudent($this);
  602.         }
  604.         return $this;
  605.     }
  607.     public function removePrimaryNote(PrimaryNote $primaryNote): static
  608.     {
  609.         if ($this->primaryNotes->removeElement($primaryNote)) {
  610.             // set the owning side to null (unless already changed)
  611.             if ($primaryNote->getStudent() === $this) {
  612.                 $primaryNote->setStudent(null);
  613.             }
  614.         }
  616.         return $this;
  617.     }
  619.     /**
  620.      * @return Collection<int, DisciplinePunish>
  621.      */
  622.     public function getDisciplinePunishes(): Collection
  623.     {
  624.         return $this->disciplinePunishes;
  625.     }
  627.     public function addDisciplinePunish(DisciplinePunish $disciplinePunish): static
  628.     {
  629.         if (!$this->disciplinePunishes->contains($disciplinePunish)) {
  630.             $this->disciplinePunishes->add($disciplinePunish);
  631.             $disciplinePunish->setStudent($this);
  632.         }
  634.         return $this;
  635.     }
  637.     public function removeDisciplinePunish(DisciplinePunish $disciplinePunish): static
  638.     {
  639.         if ($this->disciplinePunishes->removeElement($disciplinePunish)) {
  640.             // set the owning side to null (unless already changed)
  641.             if ($disciplinePunish->getStudent() === $this) {
  642.                 $disciplinePunish->setStudent(null);
  643.             }
  644.         }
  646.         return $this;
  647.     }
  648.     
  649.     public function getPicture(): ?string
  650.     {
  651.         return $this->picture;
  652.     }
  654.     public function setPicture(?string $picture): static
  655.     {
  656.         $this->picture = $picture;
  658.         return $this;
  659.     }
  661.     public function getBornArrondissement(): ?string
  662.     {
  663.         return $this->bornArrondissement;
  664.     }
  666.     public function setBornArrondissement(?string $bornArrondissement): static
  667.     {
  668.         $this->bornArrondissement = $bornArrondissement;
  670.         return $this;
  671.     }
  673.     public function getBornDepartement(): ?string
  674.     {
  675.         return $this->bornDepartement;
  676.     }
  678.     public function setBornDepartement(?string $bornDepartement): static
  679.     {
  680.         $this->bornDepartement = $bornDepartement;
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection<int, Blame>
  687.      */
  688.     public function getBlames(): Collection
  689.     {
  690.         return $this->blames;
  691.     }
  693.     public function addBlame(Blame $blame): static
  694.     {
  695.         if (!$this->blames->contains($blame)) {
  696.             $this->blames->add($blame);
  697.             $blame->setStudent($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeBlame(Blame $blame): static
  704.     {
  705.         if ($this->blames->removeElement($blame)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($blame->getStudent() === $this) {
  708.                 $blame->setStudent(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, Warning>
  717.      */
  718.     public function getWarnings(): Collection
  719.     {
  720.         return $this->warnings;
  721.     }
  723.     public function addWarning(Warning $warning): static
  724.     {
  725.         if (!$this->warnings->contains($warning)) {
  726.             $this->warnings->add($warning);
  727.             $warning->setStudent($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removeWarning(Warning $warning): static
  734.     {
  735.         if ($this->warnings->removeElement($warning)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($warning->getStudent() === $this) {
  738.                 $warning->setStudent(null);
  739.             }
  740.         }
  742.         return $this;
  743.     }
  745.     /**
  746.      * @return Collection<int, Retained>
  747.      */
  748.     public function getRetaineds(): Collection
  749.     {
  750.         return $this->retaineds;
  751.     }
  753.     public function addRetained(Retained $retained): static
  754.     {
  755.         if (!$this->retaineds->contains($retained)) {
  756.             $this->retaineds->add($retained);
  757.             $retained->setStudent($this);
  758.         }
  760.         return $this;
  761.     }
  763.     public function removeRetained(Retained $retained): static
  764.     {
  765.         if ($this->retaineds->removeElement($retained)) {
  766.             // set the owning side to null (unless already changed)
  767.             if ($retained->getStudent() === $this) {
  768.                 $retained->setStudent(null);
  769.             }
  770.         }
  772.         return $this;
  773.     }
  775.     public function getFather(): ?string
  776.     {
  777.         return $this->father;
  778.     }
  780.     public function setFather(?string $father): static
  781.     {
  782.         $this->father = $father;
  784.         return $this;
  785.     }
  787.     public function getMother(): ?string
  788.     {
  789.         return $this->mother;
  790.     }
  792.     public function setMother(?string $mother): static
  793.     {
  794.         $this->mother = $mother;
  796.         return $this;
  797.     }
  799.     public function getBornDay(): ?\DateTimeInterface
  800.     {
  801.         return $this->bornDay;
  802.     }
  804.     public function setBornDay(?\DateTimeInterface $bornDay): static
  805.     {
  806.         $this->bornDay = $bornDay;
  808.         return $this;
  809.     }
  810. }