src/Entity/StudentYear.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\StudentYearRepository;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use App\Entity\Traits\Timestampable;
  10. use Symfony\Component\HttpFoundation\File\File;
  11. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  12. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
  13. use JMS\Serializer\Annotation\Groups;
  15. #[ORM\HasLifecycleCallbacks]
  16. #[Vich\Uploadable]
  17. #[ORM\Entity(repositoryClass: StudentYearRepository::class)]
  18. class StudentYear
  19. {
  20.     use Timestampable;
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     #[Groups(['getStudents'])]
  25.     private ?int $id = null;
  27.     #[ORM\ManyToOne(inversedBy: 'studentYears', cascade: ["persist"])]
  28.     #[Groups(['getStudents'])]
  29.     private ?SchoolYear $year = null;
  31.     #[ORM\ManyToOne(inversedBy: 'studentYears', cascade: ["persist"])]
  32.     #[Groups(['getStudents','getExamStudent'])]
  33.     private ?Student $student = null;
  34.   /**
  35.     * NOTE: This is not a mapped field of entity metadata, just a simple property.
  36.     *
  37.    */
  38.    #[Vich\UploadableField(mapping: 'student_profile', fileNameProperty: 'imageName')]
  39.    private ?File $imageFile = null;
  41.    #[ORM\Column(length: 255, nullable: true)]
  42.    private ?string $imageName = null;
  44.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'studentYears')]
  45.     #[ORM\JoinColumn(nullable: false)]
  46.     #[Groups(['getStudents','getExamStudent'])]
  47.     private ?TheClass $classe = null;
  49.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'studentYears')]
  50.     #[Groups(['getStudents'])]
  51.     private ?School $school = null;
  53.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: StudentScolarity::class)]
  54.     private Collection $studentScolarities;
  56.     /**
  57.      * Matières dont cet élève est dispensé pour cette inscription (classe + année).
  58.      *
  59.      * @var Collection<int, StudentSubjectExemption>
  60.      */
  61.     #[ORM\OneToMany(mappedBy: 'studentYear', targetEntity: StudentSubjectExemption::class, orphanRemoval: true)]
  62.     private Collection $subjectExemptions;
  64.     #[ORM\ManyToOne(cascade: ["persist"], inversedBy: 'students')]
  65.     private ?Scolarity $scolarity = null;
  67.     #[ORM\OneToMany(mappedBy: 'student', targetEntity: ScolarityHistory::class)]
  68.     private Collection $scolarityHistories;
  70.     #[ORM\Column(length: 255, nullable: true)]
  71.     private ?string $slug = null;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $lastSchoolName = null;
  76.     #[ORM\Column(nullable: true)]
  77.     private ?bool $repeater = null;
  79.     #[ORM\Column(type: 'boolean', options: ['default' => true])]
  80.     private ?bool $active = null;
  82.     public function __construct()
  83.     {
  84.         $this->active = true;
  85.         $this->studentScolarities = new ArrayCollection();
  86.         $this->scolarityHistories = new ArrayCollection();
  87.         $this->subjectExemptions = new ArrayCollection();
  88.     }
  90.     public function getId(): ?int
  91.     {
  92.         return $this->id;
  93.     }
  95.     public function getYear(): ?SchoolYear
  96.     {
  97.         return $this->year;
  98.     }
  100.     public function setYear(?SchoolYear $year): static
  101.     {
  102.         $this->year = $year;
  104.         return $this;
  105.     }
  107.     public function getStudent(): ?Student
  108.     {
  109.         return $this->student;
  110.     }
  112.     public function setStudent(?Student $student): static
  113.     {
  114.         $this->student = $student;
  116.         return $this;
  117.     }
  119.     public function getClasse(): ?TheClass
  120.     {
  121.         return $this->classe;
  122.     }
  124.     public function setClasse(?TheClass $classe): static
  125.     {
  126.         $this->classe = $classe;
  128.         return $this;
  129.     }
  131.     /**
  132.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  133.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  134.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  135.      * must be able to accept an instance of 'File' as the bundle will inject one here
  136.      * during Doctrine hydration.
  137.      *
  138.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  139.      */
  140.     public function setImageFile(?File $imageFile = null): void
  141.     {
  142.         $this->imageFile = $imageFile;
  144.         if (null !== $imageFile) {
  145.             // It is required that at least one field changes if you are using doctrine
  146.             // otherwise the event listeners won't be called and the file is lost
  147.             $this->setUpdatedAt(new \DateTime());
  148.         }
  149.     }
  151.     public function getImageFile(): ?File
  152.     {
  153.         return $this->imageFile;
  154.     }
  156.     public function getImageName(): ?string
  157.     {
  158.         return $this->imageName;
  159.     }
  161.     public function setImageName(?string $imageName): static
  162.     {
  163.         $this->imageName = $imageName;
  165.         return $this;
  166.     }
  168.     /**
  169.      * @return Collection<int, StudentScolarity>
  170.      */
  171.     public function getStudentScolarities(): Collection
  172.     {
  173.         return $this->studentScolarities;
  174.     }
  176.     public function addStudentScolarity(StudentScolarity $studentScolarity): static
  177.     {
  178.         if (!$this->studentScolarities->contains($studentScolarity)) {
  179.             $this->studentScolarities->add($studentScolarity);
  180.             $studentScolarity->setStudent($this);
  181.         }
  183.         return $this;
  184.     }
  186.     public function removeStudentScolarity(StudentScolarity $studentScolarity): static
  187.     {
  188.         if ($this->studentScolarities->removeElement($studentScolarity)) {
  189.             // set the owning side to null (unless already changed)
  190.             if ($studentScolarity->getStudent() === $this) {
  191.                 $studentScolarity->setStudent(null);
  192.             }
  193.         }
  195.         return $this;
  196.     }
  198.     /**
  199.      * @return Collection<int, StudentSubjectExemption>
  200.      */
  201.     public function getSubjectExemptions(): Collection
  202.     {
  203.         return $this->subjectExemptions;
  204.     }
  206.     public function addSubjectExemption(StudentSubjectExemption $subjectExemption): static
  207.     {
  208.         if (!$this->subjectExemptions->contains($subjectExemption)) {
  209.             $this->subjectExemptions->add($subjectExemption);
  210.             $subjectExemption->setStudentYear($this);
  211.         }
  213.         return $this;
  214.     }
  216.     public function removeSubjectExemption(StudentSubjectExemption $subjectExemption): static
  217.     {
  218.         if ($this->subjectExemptions->removeElement($subjectExemption)) {
  219.             if ($subjectExemption->getStudentYear() === $this) {
  220.                 $subjectExemption->setStudentYear(null);
  221.             }
  222.         }
  224.         return $this;
  225.     }
  227.     public function getScolarity(): ?Scolarity
  228.     {
  229.         return $this->scolarity;
  230.     }
  232.     public function setScolarity(?Scolarity $scolarity): static
  233.     {
  234.         $this->scolarity = $scolarity;
  236.         return $this;
  237.     }
  239.     /**
  240.      * @return Collection<int, ScolarityHystory>
  241.      */
  242.     public function getScolarityHistories(): Collection
  243.     {
  244.         return $this->scolarityHistories;
  245.     }
  247.     public function addScolarityHistory(ScolarityHistory $scolarityHistory): static
  248.     {
  249.         if (!$this->scolarityHistories->contains($scolarityHistory)) {
  250.             $this->scolarityHistories->add($scolarityHistory);
  251.             $scolarityHistory->setStudent($this);
  252.         }
  254.         return $this;
  255.     }
  257.     public function removeScolarityHistory(ScolarityHistory $scolarityHistory): static
  258.     {
  259.         if ($this->scolarityHistories->removeElement($scolarityHistory)) {
  260.             // set the owning side to null (unless already changed)
  261.             if ($scolarityHistory->getStudent() === $this) {
  262.                 $scolarityHistory->setStudent(null);
  263.             }
  264.         }
  266.         return $this;
  267.     }
  269.     public function getSchool(): ?School
  270.     {
  271.         return $this->school;
  272.     }
  274.     public function setSchool(?School $school): static
  275.     {
  276.         $this->school = $school;
  278.         return $this;
  279.     }
  281.     public function getSlug(): ?string
  282.     {
  283.         return $this->slug;
  284.     }
  286.     public function setSlug(?string $slug): static
  287.     {
  288.         $this->slug = $slug;
  290.         return $this;
  291.     }
  293.     public function getLastSchoolName(): ?string
  294.     {
  295.         return $this->lastSchoolName;
  296.     }
  298.     public function setLastSchoolName(?string $lastSchoolName): static
  299.     {
  300.         $this->lastSchoolName = $lastSchoolName;
  302.         return $this;
  303.     }
  305.     public function isRepeater(): ?bool
  306.     {
  307.         return $this->repeater;
  308.     }
  310.     public function setRepeater(?bool $repeater): static
  311.     {
  312.         $this->repeater = $repeater;
  314.         return $this;
  315.     }
  317.     public function isActive(): ?bool
  318.     {
  319.         return $this->active;
  320.     }
  322.     public function setActive(bool $active): static
  323.     {
  324.         $this->active = $active;
  326.         return $this;
  327.     }
  328. }