src/Entity/Cours.php line 99

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
  6. use ApiPlatform\Doctrine\Orm\Filter\DateFilter;
  7. use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
  8. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  9. use ApiPlatform\Metadata\ApiFilter;
  10. use ApiPlatform\Metadata\ApiResource;
  11. use App\Repository\CoursRepository;
  12. use DateTimeImmutable;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use ApiPlatform\Metadata\Get;
  18. use ApiPlatform\Metadata\GetCollection;
  19. use App\Controller\Api\Controller\Course\DetailsController;
  20. use App\Controller\Api\Controller\Course\ShowQuizzesController;
  21. use App\Controller\Api\Controller\Course\StartCourseController;
  22. use App\Controller\Api\Controller\Course\StudentCourseController;
  23. use Symfony\Component\Serializer\Annotation\Groups;
  24. use Symfony\Component\Validator\Constraints as Assert;
  26. #[ORM\Entity(repositoryClass: CoursRepository::class)]
  27. #[
  28.     ApiResource(
  29.         operations: [
  30.             new GetCollection(
  31.                 options: ['isActivated' => true],
  32.                 normalizationContext: ['groups' => ['read:course:collection']]
  33.             ),
  34.             new Get(
  35.                 uriTemplate: '/cours/{id}/details',
  36.                 controller: DetailsController::class,
  37.                 normalizationContext: ['groups' => ['read:course:collection', 'read:course:item']],
  38.                 write: true,
  39.                 name: 'course_details'
  40.             ),
  41.             new GetCollection(
  42.                 uriTemplate: '/student/{id}/courses',
  43.                 controller: StudentCourseController::class,
  44.                 openapiContext: [
  45.                     'security' => [['bearerAuth' => []]]
  46.                 ],
  47.                 normalizationContext: [
  48.                     'groups' => ['read:course:collection']
  49.                 ],
  50.                 read: false
  51.             ),
  52.             new Get(
  53.                 uriTemplate: '/cours/{id}/start',
  54.                 controller: StartCourseController::class,
  55.                 openapiContext: [
  56.                     'security' => [['bearerAuth' => []]]
  57.                 ],
  58.                 normalizationContext: [
  59.                     'groups' => ['read:lesson:item']
  60.                 ],
  61.                 read: false
  62.             ),
  63.             new Get(
  64.                 uriTemplate: '/cours/{id}/quizzes',
  65.                 controller: ShowQuizzesController::class,
  66.                 openapiContext: [
  67.                     'security' => [['bearerAuth' => []]]
  68.                 ],
  69.                 normalizationContext: [
  70.                     'groups' => ['read:quizzes:collection']
  71.                 ],
  72.                 read: false
  73.             ),
  74.         ],
  75.         normalizationContext: [
  76.             'groups' => ['read:course:collection']
  77.         ],
  78.         paginationClientItemsPerPage: true,
  79.         paginationItemsPerPage: 10,
  80.         paginationMaximumItemsPerPage: 20,
  81.     ),
  82.     ApiFilter(
  83.         SearchFilter::class, properties: [
  84.             'id' => 'exact',
  85.             'categorie' => 'exact',
  86.             'intitule' => 'partial',
  87.             'language' => 'exact',
  88.             'classe' => 'exact',
  89.             'classe.specialite' => 'exact',
  90.             'classe.specialite.filiere' => 'exact',
  91.             'classe.skillLevel' => 'exact'
  92.         ]
  93.     ),
  94.     ApiFilter(BooleanFilter::class, properties: ['isFree', 'isValidated']),
  95.     ApiFilter(OrderFilter::class, properties: ['id', 'intitule'], arguments: ['orderParameterName' => 'order']),
  96.     ApiFilter(DateFilter::class, properties: ['publishedAt']),
  98. ]
  99. class Cours
  100. {
  101.     #[ORM\Id]
  102.     #[ORM\GeneratedValue]
  103.     #[ORM\Column]
  104.     #[Groups(['read:course:collection', 'read:payment:collection', 'read:lecture:collection', 'read:forum:item'])]
  105.     private ?int $id = null;
  107.     #[ORM\ManyToMany(targetEntity: Classe::class, inversedBy: 'cours')]
  108.     #[Groups(['read:course:collection'])]
  109.     private Collection $classe;
  111.     #[ORM\Column(length: 255)]
  112.     #[Assert\NotBlank(message: "Ne peut être vide !")]
  113.     #[Assert\NotNull(message: "Ne peut être nul !")]
  114.     #[Groups(['read:course:collection', 'read:payment:collection', 'read:lecture:collection', 'read:forum:item'])]
  115.     private ?string $intitule = null;
  117.     #[ORM\Column(length: 255)]
  118.     #[Groups(['read:course:collection', 'read:forum:item'])]
  119.     private ?string $slug = null;
  121.     #[ORM\Column(type: Types::TEXT)]
  122.     #[Assert\NotBlank(message: "Ne peut être vide !")]
  123.     #[Assert\NotNull(message: "Ne peut être nul !")]
  124.     #[Groups(['read:course:item'])]
  125.     private ?string $content = null;
  127.     #[ORM\Column(type: Types::TEXT)]
  128.     #[Assert\NotBlank(message: "Ne peut être vide !")]
  129.     #[Assert\NotNull(message: "Ne peut être nul !")]
  130.     #[Groups(['read:course:collection'])]
  131.     private ?string $description = null;
  133.     #[ORM\Column]
  134.     #[Groups(['read:course:collection', 'read:forum:item'])]
  135.     private ?bool $isPublished = null;
  137.     #[ORM\Column]
  138.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  139.     private ?bool $isFree = null;
  141.     #[ORM\OneToMany(mappedBy: 'cours', cascade: ['persist', 'remove'], targetEntity: Chapitre::class, orphanRemoval: true)]
  142.     #[Groups(['read:course:item', 'read:lesson:item'])]
  143.     private Collection $chapitres;
  145.     #[ORM\ManyToOne(inversedBy: 'cours')]
  146.     #[ORM\JoinColumn(nullable: false)]
  147.     #[Groups(['read:course:collection', 'read:forum:item'])]
  148.     private ?Enseignant $enseignant = null;
  150.     #[ORM\ManyToMany(targetEntity: Eleve::class, mappedBy: 'cours')]
  151.     
  152.     private Collection $eleves;
  154.     #[Groups(['read:course:item'])]
  155.     private $numberOfStudents;
  157.     #[ORM\ManyToMany(targetEntity: Formation::class, mappedBy: 'cours')]
  158.     private Collection $formations;
  160.     #[ORM\Column(length: 255)]
  161.     #[Assert\NotBlank(message: "Ne peut être vide !")]
  162.     #[Assert\NotNull(message: "Ne peut être nul !")]
  163.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  164.     private ?string $niveauDifficulte = null;
  166.     #[ORM\Column(length: 255)]
  167.     #[Assert\NotBlank(message: "Ne peut être vide !")]
  168.     #[Assert\NotNull(message: "Ne peut être nul !")]
  169.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  170.     private ?string $dureeApprentissage = null;
  172.     #[ORM\Column]
  173.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  174.     private ?\DateTimeImmutable $createdAt = null;
  176.     #[ORM\Column]
  177.     #[Groups(['read:course:collection', 'update:course:item'])]
  178.     private ?int $vues = null;
  180.     #[ORM\Column]
  181.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  182.     private ?bool $isValidated = null;
  184.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: Like::class, orphanRemoval: true)]
  185.     private Collection $likes;
  187.     #[ORM\Column(nullable: true)]
  188.     #[Groups(['read:course:collection'])]
  189.     private ?int $montantAbonnement = null;
  191.     #[ORM\ManyToOne(inversedBy: 'cours')]
  192.     #[Groups(['read:course:collection'])]
  193.     private ?Categorie $categorie = null;
  195.     #[ORM\OneToOne(mappedBy: 'cours', cascade: ['persist', 'remove'])]
  196.     #[Groups(['read:course:collection'])]
  197.     private ?Media $media = null;
  199.     #[ORM\OneToOne(mappedBy: 'cours', cascade: ['persist', 'remove'])]
  200.     #[Groups(['read:course:collection'])]
  201.     private ?Forum $forum = null;
  203.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: FAQ::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  204.     #[Groups(['read:course:item'])]
  205.     private Collection $fAQs;
  207.     #[ORM\Column(length: 100)]
  208.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  209.     private ?string $language = null;
  211.     #[ORM\Column(type: Types::SMALLINT)]
  212.     #[Groups(['read:course:collection', 'read:payment:collection'])]
  213.     private ?int $numberOfLessons = null;
  215.     #[ORM\Column(length: 255, nullable: true)]
  216.     #[Groups(['read:course:collection'])]
  217.     private ?string $tags = null;
  219.     #[ORM\Column(nullable: true)]
  220.     #[Groups(['read:course:collection'])]
  221.     private ?bool $isRejected = null;
  223.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: Review::class, orphanRemoval: true)]
  224.     private Collection $reviews;
  226.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  227.     #[Groups(['read:course:collection'])]
  228.     private ?int $review = null;
  230.     #[ORM\Column(nullable: true)]
  231.     #[Groups(['read:course:collection'])]
  232.     private ?\DateTimeImmutable $updatedAt = null;
  234.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: Payment::class)]
  235.     private Collection $payments;
  237.     #[ORM\ManyToMany(targetEntity: PaymentMethod::class, inversedBy: 'cours')]
  238.     #[Groups(['read:course:item'])]
  239.     private Collection $paymentMethods;
  241.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: Lecture::class)]
  242.     private Collection $lectures;
  244.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: Quiz::class)]
  245.     #[Groups(['read:quizzes:collection'])]
  246.     private Collection $quizzes;
  248.     #[ORM\Column(nullable: true)]
  249.     #[Groups(['read:course:collection'])]
  250.     private ?\DateTimeImmutable $publishedAt = null;
  252.     #[ORM\OneToMany(mappedBy: 'cours', targetEntity: QuizLost::class)]
  253.     private Collection $quizLosts;
  255.     #[ORM\ManyToOne(inversedBy: 'cours')]
  256.     private ?SkillLevel $skillLevel = null;
  258.     public function __construct()
  259.     {
  260.         $this->classe = new ArrayCollection();
  261.         $this->chapitres = new ArrayCollection();
  262.         $this->eleves = new ArrayCollection();
  263.         $this->formations = new ArrayCollection();
  264.         $this->likes = new ArrayCollection();
  265.         $this->isPublished = false;
  266.         $this->isValidated = false;
  267.         $this->isFree = true;
  268.         $this->vues = 0;
  269.         $this->createdAt = new DateTimeImmutable();
  270.         $this->fAQs = new ArrayCollection();
  271.         $this->reviews = new ArrayCollection();
  272.         $this->payments = new ArrayCollection();
  273.         $this->review = 0;
  274.         $this->paymentMethods = new ArrayCollection();
  275.         $this->lectures = new ArrayCollection();
  276.         $this->quizzes = new ArrayCollection();
  277.         $this->quizLosts = new ArrayCollection();
  278.     }
  280.     public function getId(): ?int
  281.     {
  282.         return $this->id;
  283.     }
  285.     /**
  286.      * @return Collection<int, Classe>
  287.      */
  288.     public function getClasse(): Collection
  289.     {
  290.         return $this->classe;
  291.     }
  293.     public function addClasse(Classe $classe): self
  294.     {
  295.         if (!$this->classe->contains($classe)) {
  296.             $this->classe->add($classe);
  297.         }
  299.         return $this;
  300.     }
  302.     public function removeClasse(Classe $classe): self
  303.     {
  304.         $this->classe->removeElement($classe);
  306.         return $this;
  307.     }
  309.     public function getIntitule(): ?string
  310.     {
  311.         return $this->intitule;
  312.     }
  314.     public function setIntitule(string $intitule): self
  315.     {
  316.         $this->intitule = $intitule;
  318.         return $this;
  319.     }
  321.     public function getSlug(): ?string
  322.     {
  323.         return $this->slug;
  324.     }
  326.     public function setSlug(string $slug): self
  327.     {
  328.         $this->slug = $slug;
  330.         return $this;
  331.     }
  333.     public function getContent(): ?string
  334.     {
  335.         return $this->content;
  336.     }
  338.     public function setContent(string $content): self
  339.     {
  340.         $this->content = $content;
  342.         return $this;
  343.     }
  345.     public function getDescription(): ?string
  346.     {
  347.         return $this->description;
  348.     }
  350.     public function setDescription(string $description): self
  351.     {
  352.         $this->description = $description;
  354.         return $this;
  355.     }
  357.     public function isIsPublished(): ?bool
  358.     {
  359.         return $this->isPublished;
  360.     }
  362.     public function setIsPublished(bool $isPublished): self
  363.     {
  364.         $this->isPublished = $isPublished;
  366.         return $this;
  367.     }
  369.     public function isIsFree(): ?bool
  370.     {
  371.         return $this->isFree;
  372.     }
  374.     public function setIsFree(bool $isFree): self
  375.     {
  376.         $this->isFree = $isFree;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, Chapitre>
  383.      */
  384.     public function getChapitres(): Collection
  385.     {
  386.         return $this->chapitres;
  387.     }
  389.     public function addChapitre(Chapitre $chapitre): self
  390.     {
  391.         if (!$this->chapitres->contains($chapitre)) {
  392.             $this->chapitres->add($chapitre);
  393.             $chapitre->setCours($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeChapitre(Chapitre $chapitre): self
  400.     {
  401.         if ($this->chapitres->removeElement($chapitre)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($chapitre->getCours() === $this) {
  404.                 $chapitre->setCours(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     public function getEnseignant(): ?Enseignant
  412.     {
  413.         return $this->enseignant;
  414.     }
  416.     public function setEnseignant(?Enseignant $enseignant): self
  417.     {
  418.         $this->enseignant = $enseignant;
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, Eleve>
  425.      */
  426.     public function getEleves(): Collection
  427.     {
  428.         return $this->eleves;
  429.     }
  431.     public function addElefe(Eleve $elefe): self
  432.     {
  433.         if (!$this->eleves->contains($elefe)) {
  434.             $this->eleves->add($elefe);
  435.             $elefe->addCour($this);
  436.         }
  438.         return $this;
  439.     }
  441.     public function removeElefe(Eleve $elefe): self
  442.     {
  443.         if ($this->eleves->removeElement($elefe)) {
  444.             $elefe->removeCour($this);
  445.         }
  447.         return $this;
  448.     }
  450.     /**
  451.      * @return Collection<int, Formation>
  452.      */
  453.     public function getFormations(): Collection
  454.     {
  455.         return $this->formations;
  456.     }
  458.     public function addFormation(Formation $formation): self
  459.     {
  460.         if (!$this->formations->contains($formation)) {
  461.             $this->formations->add($formation);
  462.             $formation->addCour($this);
  463.         }
  465.         return $this;
  466.     }
  468.     public function removeFormation(Formation $formation): self
  469.     {
  470.         if ($this->formations->removeElement($formation)) {
  471.             $formation->removeCour($this);
  472.         }
  474.         return $this;
  475.     }
  477.     public function getNiveauDifficulte(): ?string
  478.     {
  479.         return $this->niveauDifficulte;
  480.     }
  482.     public function setNiveauDifficulte(string $niveauDifficulte): self
  483.     {
  484.         $this->niveauDifficulte = $niveauDifficulte;
  486.         return $this;
  487.     }
  489.     public function getDureeApprentissage(): ?string
  490.     {
  491.         return $this->dureeApprentissage;
  492.     }
  494.     public function setDureeApprentissage(string $dureeApprentissage): self
  495.     {
  496.         $this->dureeApprentissage = $dureeApprentissage;
  498.         return $this;
  499.     }
  501.     public function getCreatedAt(): ?\DateTimeImmutable
  502.     {
  503.         return $this->createdAt;
  504.     }
  506.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  507.     {
  508.         $this->createdAt = $createdAt;
  510.         return $this;
  511.     }
  513.     public function getVues(): ?int
  514.     {
  515.         return $this->vues;
  516.     }
  518.     public function setVues(int $vues): self
  519.     {
  520.         $this->vues = $vues;
  522.         return $this;
  523.     }
  525.     public function isIsValidated(): ?bool
  526.     {
  527.         return $this->isValidated;
  528.     }
  530.     public function setIsValidated(bool $isValidated): self
  531.     {
  532.         $this->isValidated = $isValidated;
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, Like>
  539.      */
  540.     public function getLikes(): Collection
  541.     {
  542.         return $this->likes;
  543.     }
  545.     public function addLike(Like $like): self
  546.     {
  547.         if (!$this->likes->contains($like)) {
  548.             $this->likes->add($like);
  549.             $like->setCours($this);
  550.         }
  552.         return $this;
  553.     }
  555.     public function removeLike(Like $like): self
  556.     {
  557.         if ($this->likes->removeElement($like)) {
  558.             // set the owning side to null (unless already changed)
  559.             if ($like->getCours() === $this) {
  560.                 $like->setCours(null);
  561.             }
  562.         }
  564.         return $this;
  565.     }
  567.     public function getMontantAbonnement(): ?int
  568.     {
  569.         return $this->montantAbonnement;
  570.     }
  572.     public function setMontantAbonnement(?int $montantAbonnement): self
  573.     {
  574.         $this->montantAbonnement = $montantAbonnement;
  576.         return $this;
  577.     }
  579.     public function getProf(): ?string
  580.     {
  581.         return $this->enseignant->getUtilisateur()->getPersonne()->getName();
  582.     }
  584.     public function getCategorie(): ?Categorie
  585.     {
  586.         return $this->categorie;
  587.     }
  589.     public function setCategorie(?Categorie $categorie): self
  590.     {
  591.         $this->categorie = $categorie;
  593.         return $this;
  594.     }
  596.     public function getMedia(): ?Media
  597.     {
  598.         return $this->media;
  599.     }
  601.     public function setMedia(Media $media): self
  602.     {
  603.         // set the owning side of the relation if necessary
  604.         if ($media->getCours() !== $this) {
  605.             $media->setCours($this);
  606.         }
  608.         $this->media = $media;
  610.         return $this;
  611.     }
  613.     public function getForum(): ?Forum
  614.     {
  615.         return $this->forum;
  616.     }
  618.     public Function setForum(Forum $forum): self
  619.     {
  620.         if ($forum->getCours() !== $this) {
  621.             $forum->setCours($this);
  622.         }
  624.         $this->forum = $forum;
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, FAQ>
  631.      */
  632.     public function getFAQs(): Collection
  633.     {
  634.         return $this->fAQs;
  635.     }
  637.     public function addFAQ(FAQ $fAQ): self
  638.     {
  639.         if (!$this->fAQs->contains($fAQ)) {
  640.             $this->fAQs->add($fAQ);
  641.             $fAQ->setCours($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeFAQ(FAQ $fAQ): self
  648.     {
  649.         if ($this->fAQs->removeElement($fAQ)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($fAQ->getCours() === $this) {
  652.                 $fAQ->setCours(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  659.     public function getLanguage(): ?string
  660.     {
  661.         return $this->language;
  662.     }
  664.     public function setLanguage(string $language): self
  665.     {
  666.         $this->language = $language;
  668.         return $this;
  669.     }
  671.     public function getNumberOfLessons(): ?int
  672.     {
  673.         return $this->numberOfLessons;
  674.     }
  676.     public function setNumberOfLessons(int $numberOfLessons): self
  677.     {
  678.         $this->numberOfLessons = $numberOfLessons;
  680.         return $this;
  681.     }
  683.     public function getTags(): ?string
  684.     {
  685.         return $this->tags;
  686.     }
  688.     public function setTags(?string $tags): self
  689.     {
  690.         $this->tags = $tags;
  692.         return $this;
  693.     }
  695.     public function isIsRejected(): ?bool
  696.     {
  697.         return $this->isRejected;
  698.     }
  700.     public function setIsRejected(?bool $isRejected): self
  701.     {
  702.         $this->isRejected = $isRejected;
  704.         return $this;
  705.     }
  707.     /**
  708.      * @return Collection<int, Review>
  709.      */
  710.     public function getReviews(): Collection
  711.     {
  712.         return $this->reviews;
  713.     }
  715.     public function addReview(Review $review): self
  716.     {
  717.         if (!$this->reviews->contains($review)) {
  718.             $this->reviews->add($review);
  719.             $review->setCours($this);
  720.         }
  722.         return $this;
  723.     }
  725.     public function removeReview(Review $review): self
  726.     {
  727.         if ($this->reviews->removeElement($review)) {
  728.             // set the owning side to null (unless already changed)
  729.             if ($review->getCours() === $this) {
  730.                 $review->setCours(null);
  731.             }
  732.         }
  734.         return $this;
  735.     }
  737.     public function getReview(): ?int
  738.     {
  739.         return $this->review;
  740.     }
  742.     public function setReview(?int $review): self
  743.     {
  744.         $this->review = $review;
  746.         return $this;
  747.     }
  749.     public function getUpdatedAt(): ?\DateTimeImmutable
  750.     {
  751.         return $this->updatedAt;
  752.     }
  754.     public function setUpdatedAt(?\DateTimeImmutable $updatedAt): self
  755.     {
  756.         $this->updatedAt = $updatedAt;
  758.         return $this;
  759.     }
  761.     /**
  762.      * @return Collection<int, Payment>
  763.      */
  764.     public function getPayments(): Collection
  765.     {
  766.         return $this->payments;
  767.     }
  769.     public function addPayment(Payment $payment): self
  770.     {
  771.         if (!$this->payments->contains($payment)) {
  772.             $this->payments->add($payment);
  773.             $payment->setCours($this);
  774.         }
  776.         return $this;
  777.     }
  779.     public function removePayment(Payment $payment): self
  780.     {
  781.         if ($this->payments->removeElement($payment)) {
  782.             // set the owning side to null (unless already changed)
  783.             if ($payment->getCours() === $this) {
  784.                 $payment->setCours(null);
  785.             }
  786.         }
  788.         return $this;
  789.     }
  791.     /**
  792.      * @return Collection<int, PaymentMethod>
  793.      */
  794.     public function getPaymentMethods(): Collection
  795.     {
  796.         return $this->paymentMethods;
  797.     }
  799.     public function addPaymentMethod(PaymentMethod $paymentMethod): self
  800.     {
  801.         if (!$this->paymentMethods->contains($paymentMethod)) {
  802.             $this->paymentMethods->add($paymentMethod);
  803.         }
  805.         return $this;
  806.     }
  808.     public function removePaymentMethod(PaymentMethod $paymentMethod): self
  809.     {
  810.         $this->paymentMethods->removeElement($paymentMethod);
  812.         return $this;
  813.     }
  815.     /**
  816.      * @return Collection<int, Lecture>
  817.      */
  818.     public function getLectures(): Collection
  819.     {
  820.         return $this->lectures;
  821.     }
  823.     public function addLecture(Lecture $lecture): self
  824.     {
  825.         if (!$this->lectures->contains($lecture)) {
  826.             $this->lectures->add($lecture);
  827.             $lecture->setCours($this);
  828.         }
  830.         return $this;
  831.     }
  833.     public function removeLecture(Lecture $lecture): self
  834.     {
  835.         if ($this->lectures->removeElement($lecture)) {
  836.             // set the owning side to null (unless already changed)
  837.             if ($lecture->getCours() === $this) {
  838.                 $lecture->setCours(null);
  839.             }
  840.         }
  842.         return $this;
  843.     }
  845.     /**
  846.      * @return Collection<int, Quiz>
  847.      */
  848.     public function getQuizzes(): Collection
  849.     {
  850.         return $this->quizzes;
  851.     }
  853.     public function addQuiz(Quiz $quiz): self
  854.     {
  855.         if (!$this->quizzes->contains($quiz)) {
  856.             $this->quizzes->add($quiz);
  857.             $quiz->setCours($this);
  858.         }
  860.         return $this;
  861.     }
  863.     public function removeQuiz(Quiz $quiz): self
  864.     {
  865.         if ($this->quizzes->removeElement($quiz)) {
  866.             // set the owning side to null (unless already changed)
  867.             if ($quiz->getCours() === $this) {
  868.                 $quiz->setCours(null);
  869.             }
  870.         }
  872.         return $this;
  873.     }
  875.     public function getPublishedAt(): ?\DateTimeImmutable
  876.     {
  877.         return $this->publishedAt;
  878.     }
  880.     public function setPublishedAt(?\DateTimeImmutable $publishedAt): self
  881.     {
  882.         $this->publishedAt = $publishedAt;
  884.         return $this;
  885.     }
  887.     /**
  888.      * @return Collection<int, QuizLost>
  889.      */
  890.     public function getQuizLosts(): Collection
  891.     {
  892.         return $this->quizLosts;
  893.     }
  895.     public function addQuizLost(QuizLost $quizLost): self
  896.     {
  897.         if (!$this->quizLosts->contains($quizLost)) {
  898.             $this->quizLosts->add($quizLost);
  899.             $quizLost->setCours($this);
  900.         }
  902.         return $this;
  903.     }
  905.     public function removeQuizLost(QuizLost $quizLost): self
  906.     {
  907.         if ($this->quizLosts->removeElement($quizLost)) {
  908.             // set the owning side to null (unless already changed)
  909.             if ($quizLost->getCours() === $this) {
  910.                 $quizLost->setCours(null);
  911.             }
  912.         }
  914.         return $this;
  915.     }
  917.     public function getNumberOfStudents(): int
  918.     {
  919.         return $this->getEleves()->count();
  920.     }
  922.     public function getSkillLevel(): ?SkillLevel
  923.     {
  924.         return $this->skillLevel;
  925.     }
  927.     public function setSkillLevel(?SkillLevel $skillLevel): self
  928.     {
  929.         $this->skillLevel = $skillLevel;
  931.         return $this;
  932.     }
  933. }