src/Entity/Categorie.php line 38

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\GetCollection;
  7. use ApiPlatform\Metadata\Get;
  8. use App\Repository\CategorieRepository;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  15. #[ORM\Entity(repositoryClass: CategorieRepository::class)]
  16. #[ORM\Table(name: 'categorie')]
  17. #[ORM\Index(columns: ['name'], name: 'idx_categorie_name')]
  18. #[ApiResource(
  19.     operations: [
  20.         new Get(
  21.             normalizationContext: [
  22.                 'groups' => ['read:category:item', 'read:category:collection']
  23.             ]
  24.         ),
  25.         new GetCollection(
  26.             normalizationContext: [
  27.                 'groups' => ['read:category:collection']
  28.             ],
  29.             paginationClientItemsPerPage: true,
  30.             paginationItemsPerPage: 30,
  31.             paginationMaximumItemsPerPage: 25,
  32.         ),
  33.     ],
  34.     normalizationContext: [
  35.         'groups' => ['read:category:collection']
  36.     ],
  37. )]
  38. class Categorie
  39. {
  40.     #[ORM\Id]
  41.     #[ORM\GeneratedValue]
  42.     #[ORM\Column]
  43.     #[Groups(['read:course:collection', 'read:category:collection', 'read:evaluation:collection'])]
  44.     private ?int $id = null;
  46.     #[ORM\Column(length: 255)]
  47.     #[Groups(['read:course:collection', 'read:category:collection', 'read:evaluation:collection'])]
  48.     private ?string $name = null;
  50.     #[ORM\Column(length: 255)]
  51.     #[Groups(['read:course:collection', 'read:category:collection', 'read:evaluation:collection'])]
  52.     private ?string $slug = null;
  54.     #[ORM\OneToMany(mappedBy: 'categorie', targetEntity: Cours::class)]
  55.     private Collection $cours;
  57.     #[ORM\Column(length: 255, nullable: true)]
  58.     #[Groups(['read:category:collection'])]
  59.     private ?string $imageFile = null;
  61.     /**
  62.      * @var File
  63.      */
  64.     public $image;
  66.     #[ORM\Column(nullable: false)]
  67.     #[Groups(['read:category:collection'])]
  68.     private ?bool $isSubCategory = null;
  70.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'subCategories')]
  71.     private ?self $category = null;
  73.     #[ORM\OneToMany(mappedBy: 'category', targetEntity: self::class)]
  74.     private Collection $subCategories;
  76.     #[ORM\OneToMany(mappedBy: 'discipline', targetEntity: Enseignant::class)]
  77.     private Collection $enseignants;
  79.     #[ORM\OneToMany(mappedBy: 'category', targetEntity: Exam::class)]
  80.     private Collection $exams;
  82.     #[ORM\OneToMany(mappedBy: 'matiere', targetEntity: Evaluation::class, orphanRemoval: true)]
  83.     private Collection $evaluations;
  85.     #[ORM\OneToMany(mappedBy: 'matiere', targetEntity: MatiereCycle::class, orphanRemoval: true)]
  86.     private Collection $matiereCycles;
  88.     #[ORM\OneToMany(mappedBy: 'matiere', targetEntity: SubjectChat::class, orphanRemoval: true)]
  89.     private Collection $subjectChats;
  91.     public function __construct()
  92.     {
  93.         $this->cours = new ArrayCollection();
  94.         $this->subCategories = new ArrayCollection();
  95.         $this->enseignants = new ArrayCollection();
  96.         $this->exams = new ArrayCollection();
  97.         $this->isSubCategory = false;
  98.         $this->evaluations = new ArrayCollection();
  99.         $this->matiereCycles = new ArrayCollection();
  100.         $this->subjectChats = new ArrayCollection();
  101.     }
  103.     public function getId(): ?int
  104.     {
  105.         return $this->id;
  106.     }
  108.     public function getName(): ?string
  109.     {
  110.         return $this->name;
  111.     }
  113.     public function setName(string $name): self
  114.     {
  115.         $this->name = $name;
  117.         return $this;
  118.     }
  120.     public function getSlug(): ?string
  121.     {
  122.         return $this->slug;
  123.     }
  125.     public function setSlug(string $slug): self
  126.     {
  127.         $this->slug = $slug;
  129.         return $this;
  130.     }
  132.     /**
  133.      * @return Collection<int, Cours>
  134.      */
  135.     public function getCours(): Collection
  136.     {
  137.         return $this->cours;
  138.     }
  140.     public function addCour(Cours $cour): self
  141.     {
  142.         if (!$this->cours->contains($cour)) {
  143.             $this->cours->add($cour);
  144.             $cour->setCategorie($this);
  145.         }
  147.         return $this;
  148.     }
  150.     public function removeCour(Cours $cour): self
  151.     {
  152.         if ($this->cours->removeElement($cour)) {
  153.             // set the owning side to null (unless already changed)
  154.             if ($cour->getCategorie() === $this) {
  155.                 $cour->setCategorie(null);
  156.             }
  157.         }
  159.         return $this;
  160.     }
  162.     public function getImageFile(): ?string
  163.     {
  164.         return $this->imageFile;
  165.     }
  167.     public function setImageFile(?string $imageFile): self
  168.     {
  169.         $this->imageFile = $imageFile;
  171.         return $this;
  172.     }
  174.     public function isIsSubCategory(): ?bool
  175.     {
  176.         return $this->isSubCategory;
  177.     }
  179.     public function setIsSubCategory(?bool $isSubCategory): self
  180.     {
  181.         $this->isSubCategory = $isSubCategory;
  183.         return $this;
  184.     }
  186.     public function getCategory(): ?self
  187.     {
  188.         return $this->category;
  189.     }
  191.     public function setCategory(?self $category): self
  192.     {
  193.         $this->category = $category;
  195.         return $this;
  196.     }
  198.     /**
  199.      * @return Collection<int, self>
  200.      */
  201.     public function getSubCategories(): Collection
  202.     {
  203.         return $this->subCategories;
  204.     }
  206.     public function addSubCategory(self $subCategory): self
  207.     {
  208.         if (!$this->subCategories->contains($subCategory)) {
  209.             $this->subCategories->add($subCategory);
  210.             $subCategory->setCategory($this);
  211.         }
  213.         return $this;
  214.     }
  216.     public function removeSubCategory(self $subCategory): self
  217.     {
  218.         if ($this->subCategories->removeElement($subCategory)) {
  219.             // set the owning side to null (unless already changed)
  220.             if ($subCategory->getCategory() === $this) {
  221.                 $subCategory->setCategory(null);
  222.             }
  223.         }
  225.         return $this;
  226.     }
  228.     /**
  229.      * @return Collection<int, Enseignant>
  230.      */
  231.     public function getEnseignants(): Collection
  232.     {
  233.         return $this->enseignants;
  234.     }
  236.     public function addEnseignant(Enseignant $enseignant): self
  237.     {
  238.         if (!$this->enseignants->contains($enseignant)) {
  239.             $this->enseignants->add($enseignant);
  240.             $enseignant->setDiscipline($this);
  241.         }
  243.         return $this;
  244.     }
  246.     public function removeEnseignant(Enseignant $enseignant): self
  247.     {
  248.         if ($this->enseignants->removeElement($enseignant)) {
  249.             // set the owning side to null (unless already changed)
  250.             if ($enseignant->getDiscipline() === $this) {
  251.                 $enseignant->setDiscipline(null);
  252.             }
  253.         }
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return Collection<int, Exam>
  260.      */
  261.     public function getExams(): Collection
  262.     {
  263.         return $this->exams;
  264.     }
  266.     public function addExam(Exam $exam): self
  267.     {
  268.         if (!$this->exams->contains($exam)) {
  269.             $this->exams->add($exam);
  270.             $exam->setCategory($this);
  271.         }
  273.         return $this;
  274.     }
  276.     public function removeExam(Exam $exam): self
  277.     {
  278.         if ($this->exams->removeElement($exam)) {
  279.             // set the owning side to null (unless already changed)
  280.             if ($exam->getCategory() === $this) {
  281.                 $exam->setCategory(null);
  282.             }
  283.         }
  285.         return $this;
  286.     }
  288.     /**
  289.      * @return Collection<int, Evaluation>
  290.      */
  291.     public function getEvaluations(): Collection
  292.     {
  293.         return $this->evaluations;
  294.     }
  296.     public function addEvaluation(Evaluation $evaluation): self
  297.     {
  298.         if (!$this->evaluations->contains($evaluation)) {
  299.             $this->evaluations->add($evaluation);
  300.             $evaluation->setMatiere($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeEvaluation(Evaluation $evaluation): self
  307.     {
  308.         if ($this->evaluations->removeElement($evaluation)) {
  309.             // set the owning side to null (unless already changed)
  310.             if ($evaluation->getMatiere() === $this) {
  311.                 $evaluation->setMatiere(null);
  312.             }
  313.         }
  315.         return $this;
  316.     }
  318.     /**
  319.      * @return Collection<int, MatiereCycle>
  320.      */
  321.     public function getMatiereCycles(): Collection
  322.     {
  323.         return $this->matiereCycles;
  324.     }
  326.     public function addMatiereCycle(MatiereCycle $matiereCycle): static
  327.     {
  328.         if (!$this->matiereCycles->contains($matiereCycle)) {
  329.             $this->matiereCycles->add($matiereCycle);
  330.             $matiereCycle->setMatiere($this);
  331.         }
  333.         return $this;
  334.     }
  336.     public function removeMatiereCycle(MatiereCycle $matiereCycle): static
  337.     {
  338.         if ($this->matiereCycles->removeElement($matiereCycle)) {
  339.             // set the owning side to null (unless already changed)
  340.             if ($matiereCycle->getMatiere() === $this) {
  341.                 $matiereCycle->setMatiere(null);
  342.             }
  343.         }
  345.         return $this;
  346.     }
  348.     /**
  349.      * @return Collection<int, SubjectChat>
  350.      */
  351.     public function getSubjectChats(): Collection
  352.     {
  353.         return $this->subjectChats;
  354.     }
  356.     public function addSubjectChat(SubjectChat $chat): static
  357.     {
  358.         if (!$this->subjectChats->contains($chat)) {
  359.             $this->subjectChats->add($chat);
  360.             $chat->setMatiere($this);
  361.         }
  362.         return $this;
  363.     }
  365.     public function removeSubjectChat(SubjectChat $chat): static
  366.     {
  367.         if ($this->subjectChats->removeElement($chat)) {
  368.             if ($chat->getMatiere() === $this) {
  369.                 $chat->setMatiere(null);
  370.             }
  371.         }
  372.         return $this;
  373.     }
  374. }