src/Entity/Classe.php line 32

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  6. use ApiPlatform\Metadata\ApiFilter;
  7. use ApiPlatform\Metadata\ApiResource;
  8. use ApiPlatform\Metadata\GetCollection;
  9. use App\Repository\ClasseRepository;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\ORM\Mapping as ORM;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use Symfony\Component\Validator\Constraints as Assert;
  16. #[ORM\Entity(repositoryClass: ClasseRepository::class)]
  17. #[
  18.     ApiResource(
  19.         operations: [
  20.             new GetCollection(
  21.                 normalizationContext: ['groups' => ['read:classe:collection']]
  22.             )
  23.         ]
  24.     ),
  25.     ApiFilter(SearchFilter::class, properties: [
  26.         'specialite' => 'exact',
  27.         'specialite.filiere' => 'exact',
  28.         'sousSysteme' => 'exact',
  30.     ])
  31. ]
  32. class Classe
  33. {
  34.     #[ORM\Id]
  35.     #[ORM\GeneratedValue]
  36.     #[ORM\Column]
  37.     #[Groups(['read:classe:collection', 'read:user:item', 'read:evaluation:collection'])]
  38.     private ?int $id = null;
  40.     #[ORM\ManyToOne(inversedBy: 'classes')]
  41.     #[Groups(['read:user:item'])]
  42.     private ?Specialite $specialite = null;
  44.     #[ORM\Column(length: 255)]
  45.     #[Assert\NotBlank(message: "Le nom de classe ne peut être vide !")]
  46.     #[Assert\NotNull(message: "Le nom de classe ne peut être nul !")]
  47.     #[Groups(['read:classe:collection', 'read:user:item', 'read:evaluation:collection'])]
  48.     private ?string $name = null;
  50.     #[ORM\Column(length: 255)]
  51.     #[Groups(['read:classe:collection', 'read:user:item', 'read:evaluation:collection'])]
  52.     private ?string $slug = null;
  54.     #[ORM\ManyToMany(targetEntity: Cours::class, mappedBy: 'classe')]
  55.     private Collection $cours;
  57.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Eleve::class)]
  58.     private Collection $eleves;
  60.     #[ORM\OneToMany(mappedBy: 'classe', targetEntity: Exam::class)]
  61.     private Collection $exams;
  63.     #[ORM\ManyToOne(inversedBy: 'classes')]
  64.     #[Groups(['read:classe:collection', 'read:user:item'])]
  65.     private ?SkillLevel $skillLevel = null;
  67.     #[ORM\ManyToOne(inversedBy: 'classes')]
  68.     #[Groups(['read:classe:collection', 'read:user:item'])]
  69.     private ?SousSysteme $sousSysteme = null;
  71.     #[ORM\ManyToMany(targetEntity: Evaluation::class, mappedBy: 'classes')]
  72.     private Collection $evaluations;
  74.     public function __construct()
  75.     {
  76.         $this->cours = new ArrayCollection();
  77.         $this->eleves = new ArrayCollection();
  78.         $this->exams = new ArrayCollection();
  79.         $this->evaluations = new ArrayCollection();
  80.     }
  82.     public function getId(): ?int
  83.     {
  84.         return $this->id;
  85.     }
  87.     public function getSpecialite(): ?Specialite
  88.     {
  89.         return $this->specialite;
  90.     }
  92.     public function setSpecialite(?Specialite $specialite): self
  93.     {
  94.         $this->specialite = $specialite;
  96.         return $this;
  97.     }
  99.     public function getName(): ?string
  100.     {
  101.         return $this->name;
  102.     }
  104.     public function setName(string $name): self
  105.     {
  106.         $this->name = $name;
  108.         return $this;
  109.     }
  111.     public function getSlug(): ?string
  112.     {
  113.         return $this->slug;
  114.     }
  116.     public function setSlug(string $slug): self
  117.     {
  118.         $this->slug = $slug;
  120.         return $this;
  121.     }
  123.     /**
  124.      * @return Collection<int, Cours>
  125.      */
  126.     public function getCours(): Collection
  127.     {
  128.         return $this->cours;
  129.     }
  131.     public function addCour(Cours $cour): self
  132.     {
  133.         if (!$this->cours->contains($cour)) {
  134.             $this->cours->add($cour);
  135.             $cour->addClasse($this);
  136.         }
  138.         return $this;
  139.     }
  141.     public function removeCour(Cours $cour): self
  142.     {
  143.         if ($this->cours->removeElement($cour)) {
  144.             $cour->removeClasse($this);
  145.         }
  147.         return $this;
  148.     }
  150.     /**
  151.      * @return Collection<int, Eleve>
  152.      */
  153.     public function getEleves(): Collection
  154.     {
  155.         return $this->eleves;
  156.     }
  158.     public function addElefe(Eleve $elefe): self
  159.     {
  160.         if (!$this->eleves->contains($elefe)) {
  161.             $this->eleves->add($elefe);
  162.             $elefe->setClasse($this);
  163.         }
  165.         return $this;
  166.     }
  168.     public function removeElefe(Eleve $elefe): self
  169.     {
  170.         if ($this->eleves->removeElement($elefe)) {
  171.             // set the owning side to null (unless already changed)
  172.             if ($elefe->getClasse() === $this) {
  173.                 $elefe->setClasse(null);
  174.             }
  175.         }
  177.         return $this;
  178.     }
  180.     /**
  181.      * @return Collection<int, Exam>
  182.      */
  183.     public function getExams(): Collection
  184.     {
  185.         return $this->exams;
  186.     }
  188.     public function addExam(Exam $exam): self
  189.     {
  190.         if (!$this->exams->contains($exam)) {
  191.             $this->exams->add($exam);
  192.             $exam->setClasse($this);
  193.         }
  195.         return $this;
  196.     }
  198.     public function removeExam(Exam $exam): self
  199.     {
  200.         if ($this->exams->removeElement($exam)) {
  201.             // set the owning side to null (unless already changed)
  202.             if ($exam->getClasse() === $this) {
  203.                 $exam->setClasse(null);
  204.             }
  205.         }
  207.         return $this;
  208.     }
  210.     public function getSkillLevel(): ?SkillLevel
  211.     {
  212.         return $this->skillLevel;
  213.     }
  215.     public function setSkillLevel(?SkillLevel $skillLevel): self
  216.     {
  217.         $this->skillLevel = $skillLevel;
  219.         return $this;
  220.     }
  222.     public function getSousSysteme(): ?SousSysteme
  223.     {
  224.         return $this->sousSysteme;
  225.     }
  227.     public function setSousSysteme(?SousSysteme $sousSysteme): self
  228.     {
  229.         $this->sousSysteme = $sousSysteme;
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, Evaluation>
  236.      */
  237.     public function getEvaluations(): Collection
  238.     {
  239.         return $this->evaluations;
  240.     }
  242.     public function addEvaluation(Evaluation $evaluation): self
  243.     {
  244.         if (!$this->evaluations->contains($evaluation)) {
  245.             $this->evaluations->add($evaluation);
  246.             $evaluation->addClass($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeEvaluation(Evaluation $evaluation): self
  253.     {
  254.         if ($this->evaluations->removeElement($evaluation)) {
  255.             $evaluation->removeClass($this);
  256.         }
  258.         return $this;
  259.     }
  260. }