src/Entity/Eleve.php line 14

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EleveRepository;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Serializer\Annotation\Groups;
  12. #[ ORM\Entity( repositoryClass: EleveRepository::class ) ]
  14. class Eleve
  15.  {
  16.     #[ ORM\Id ]
  17.     #[ ORM\GeneratedValue ]
  18.     #[ ORM\Column ]
  19.     #[ Groups( [ 'read:course:item', 'read:user:item', 'read:quizresult:collection', 'read:review:collection' ] ) ]
  20.     private ?int $id = null;
  22.     #[ ORM\ManyToOne( inversedBy: 'eleves' ) ]
  23.     #[ Groups( [ 'post:user:item' ] ) ]
  24.     private ?Classe $classe = null;
  26.     #[ ORM\ManyToMany( targetEntity: Cours::class, inversedBy: 'eleves' ) ]
  27.     private Collection $cours;
  29.     #[ ORM\ManyToMany( targetEntity: Formation::class, mappedBy: 'eleves' ) ]
  30.     private Collection $formations;
  32.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: Reponse::class, orphanRemoval: true ) ]
  33.     private Collection $reponses;
  35.     #[ ORM\OneToOne( inversedBy: 'eleve', cascade: [ 'persist', 'remove' ] ) ]
  36.     #[ ORM\JoinColumn( nullable: false ) ]
  37.     #[ Groups( [ 'read:course:item', 'read:quizresult:collection', 'read:review:collection' ] ) ]
  38.     private ?User $utilisateur = null;
  40.     #[ ORM\ManyToOne( inversedBy: 'eleves' ) ]
  41.     #[ ORM\JoinColumn( nullable: true ) ]
  42.     #[ Groups( [ 'post:user:item' ] ) ]
  43.     private ?Etablissement $etablissement = null;
  45.     #[ ORM\Column( length: 100, unique: true ) ]
  46.     #[ Groups( [ 'read:user:item', 'read:review:collection' ] ) ]
  47.     private ?string $reference = null;
  49.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: Review::class ) ]
  50.     private Collection $reviews;
  52.     #[ ORM\Column ]
  53.     #[ Groups( [ 'read:user:item', 'read:review:collection' ] ) ]
  54.     private ?\DateTimeImmutable $joinAt = null;
  56.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: Payment::class, orphanRemoval: true ) ]
  57.     private Collection $payments;
  59.     #[ ORM\Column( nullable: true ) ]
  60.     #[ Groups( [ 'read:user:item', 'read:review:collection' ] ) ]
  61.     private ?bool $isPremium = null;
  63.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: Lecture::class, orphanRemoval: true ) ]
  64.     private Collection $lectures;
  66.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: QuizResult::class, orphanRemoval: true ) ]
  67.     private Collection $quizResults;
  69.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: QuizLost::class, orphanRemoval: true ) ]
  70.     private Collection $quizLosts;
  72.     #[ ORM\ManyToMany( targetEntity: Evaluation::class, mappedBy: 'Eleves' ) ]
  73.     private Collection $evaluations;
  75.     #[ ORM\OneToMany( mappedBy: 'eleve', targetEntity: EvaluationResultat::class, orphanRemoval: true ) ]
  76.     private Collection $evaluationResultats;
  78.     #[ORM\OneToMany(mappedBy: 'eleve', targetEntity: SubjectChat::class, orphanRemoval: true)]
  79.     private Collection $subjectChats;
  81.     public function __construct()
  82.  {
  83.         $this->cours = new ArrayCollection();
  84.         $this->formations = new ArrayCollection();
  85.         $this->reponses = new ArrayCollection();
  86.         $this->reviews = new ArrayCollection();
  87.         $this->joinAt = new DateTimeImmutable();
  88.         $this->payments = new ArrayCollection();
  89.         $this->lectures = new ArrayCollection();
  90.         $this->quizResults = new ArrayCollection();
  91.         $this->isPremium = false;
  92.         $this->quizLosts = new ArrayCollection();
  93.         $this->evaluations = new ArrayCollection();
  94.         $this->evaluationResultats = new ArrayCollection();
  95.         $this->subjectChats = new ArrayCollection();
  96.     }
  98.     public function getId(): ?int
  99.  {
  100.         return $this->id;
  101.     }
  103.     public function getClasse(): ?Classe
  104.  {
  105.         return $this->classe;
  106.     }
  108.     public function setClasse( ?Classe $classe ): self
  109.  {
  110.         $this->classe = $classe;
  112.         return $this;
  113.     }
  115.     /**
  116.     * @return Collection<int, Cours>
  117.     */
  119.     public function getCours(): Collection
  120.  {
  121.         return $this->cours;
  122.     }
  124.     public function addCour( Cours $cour ): self
  125.  {
  126.         if ( !$this->cours->contains( $cour ) ) {
  127.             $this->cours->add( $cour );
  128.         }
  130.         return $this;
  131.     }
  133.     public function removeCour( Cours $cour ): self
  134.  {
  135.         $this->cours->removeElement( $cour );
  137.         return $this;
  138.     }
  140.     /**
  141.     * @return Collection<int, Formation>
  142.     */
  144.     public function getFormations(): Collection
  145.  {
  146.         return $this->formations;
  147.     }
  149.     public function addFormation( Formation $formation ): self
  150.  {
  151.         if ( !$this->formations->contains( $formation ) ) {
  152.             $this->formations->add( $formation );
  153.             $formation->addElefe( $this );
  154.         }
  156.         return $this;
  157.     }
  159.     public function removeFormation( Formation $formation ): self
  160.  {
  161.         if ( $this->formations->removeElement( $formation ) ) {
  162.             $formation->removeElefe( $this );
  163.         }
  165.         return $this;
  166.     }
  168.     /**
  169.     * @return Collection<int, Reponse>
  170.     */
  172.     public function getReponses(): Collection
  173.  {
  174.         return $this->reponses;
  175.     }
  177.     public function addReponse( Reponse $reponse ): self
  178.  {
  179.         if ( !$this->reponses->contains( $reponse ) ) {
  180.             $this->reponses->add( $reponse );
  181.             $reponse->setEleve( $this );
  182.         }
  184.         return $this;
  185.     }
  187.     public function removeReponse( Reponse $reponse ): self
  188.  {
  189.         if ( $this->reponses->removeElement( $reponse ) ) {
  190.             // set the owning side to null ( unless already changed )
  191.             if ( $reponse->getEleve() === $this ) {
  192.                 $reponse->setEleve( null );
  193.             }
  194.         }
  196.         return $this;
  197.     }
  199.     public function getUtilisateur(): ?User
  200.  {
  201.         return $this->utilisateur;
  202.     }
  204.     public function setUtilisateur( User $utilisateur ): self
  205.  {
  206.         $this->utilisateur = $utilisateur;
  208.         return $this;
  209.     }
  211.     public function getEtablissement(): ?Etablissement
  212.  {
  213.         return $this->etablissement;
  214.     }
  216.     public function setEtablissement( ?Etablissement $etablissement ): self
  217.  {
  218.         $this->etablissement = $etablissement;
  220.         return $this;
  221.     }
  223.     public function getReference(): ?string
  224.  {
  225.         return $this->reference;
  226.     }
  228.     public function setReference( string $reference ): self
  229.  {
  230.         $this->reference = $reference;
  232.         return $this;
  233.     }
  235.     /**
  236.     * @return Collection<int, Review>
  237.     */
  239.     public function getReviews(): Collection
  240.  {
  241.         return $this->reviews;
  242.     }
  244.     public function addReview( Review $review ): self
  245.  {
  246.         if ( !$this->reviews->contains( $review ) ) {
  247.             $this->reviews->add( $review );
  248.             $review->setEleve( $this );
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeReview( Review $review ): self
  255.  {
  256.         if ( $this->reviews->removeElement( $review ) ) {
  257.             // set the owning side to null ( unless already changed )
  258.             if ( $review->getEleve() === $this ) {
  259.                 $review->setEleve( null );
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     public function getJoinAt(): ?\DateTimeImmutable
  267.  {
  268.         return $this->joinAt;
  269.     }
  271.     public function setJoinAt( \DateTimeImmutable $joinAt ): self
  272.  {
  273.         $this->joinAt = $joinAt;
  275.         return $this;
  276.     }
  278.     /**
  279.     * @return Collection<int, Payment>
  280.     */
  282.     public function getPayments(): Collection
  283.  {
  284.         return $this->payments;
  285.     }
  287.     public function addPayment( Payment $payment ): self
  288.  {
  289.         if ( !$this->payments->contains( $payment ) ) {
  290.             $this->payments->add( $payment );
  291.             $payment->setEleve( $this );
  292.         }
  294.         return $this;
  295.     }
  297.     public function removePayment( Payment $payment ): self
  298.  {
  299.         if ( $this->payments->removeElement( $payment ) ) {
  300.             // set the owning side to null ( unless already changed )
  301.             if ( $payment->getEleve() === $this ) {
  302.                 $payment->setEleve( null );
  303.             }
  304.         }
  306.         return $this;
  307.     }
  309.     public function isIsPremium(): ?bool
  310.  {
  311.         return $this->isPremium;
  312.     }
  314.     public function setIsPremium( ?bool $isPremium ): self
  315.  {
  316.         $this->isPremium = $isPremium;
  318.         return $this;
  319.     }
  321.     /**
  322.     * @return Collection<int, Lecture>
  323.     */
  325.     public function getLectures(): Collection
  326.  {
  327.         return $this->lectures;
  328.     }
  330.     public function addLecture( Lecture $lecture ): self
  331.  {
  332.         if ( !$this->lectures->contains( $lecture ) ) {
  333.             $this->lectures->add( $lecture );
  334.             $lecture->setEleve( $this );
  335.         }
  337.         return $this;
  338.     }
  340.     public function removeLecture( Lecture $lecture ): self
  341.  {
  342.         if ( $this->lectures->removeElement( $lecture ) ) {
  343.             // set the owning side to null ( unless already changed )
  344.             if ( $lecture->getEleve() === $this ) {
  345.                 $lecture->setEleve( null );
  346.             }
  347.         }
  349.         return $this;
  350.     }
  352.     /**
  353.     * @return Collection<int, QuizResult>
  354.     */
  356.     public function getQuizResults(): Collection
  357.  {
  358.         return $this->quizResults;
  359.     }
  361.     public function addQuizResult( QuizResult $quizResult ): self
  362.  {
  363.         if ( !$this->quizResults->contains( $quizResult ) ) {
  364.             $this->quizResults->add( $quizResult );
  365.             $quizResult->setEleve( $this );
  366.         }
  368.         return $this;
  369.     }
  371.     public function removeQuizResult( QuizResult $quizResult ): self
  372.  {
  373.         if ( $this->quizResults->removeElement( $quizResult ) ) {
  374.             // set the owning side to null ( unless already changed )
  375.             if ( $quizResult->getEleve() === $this ) {
  376.                 $quizResult->setEleve( null );
  377.             }
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.     * @return Collection<int, QuizLost>
  385.     */
  387.     public function getQuizLosts(): Collection
  388.  {
  389.         return $this->quizLosts;
  390.     }
  392.     public function addQuizLost( QuizLost $quizLost ): self
  393.  {
  394.         if ( !$this->quizLosts->contains( $quizLost ) ) {
  395.             $this->quizLosts->add( $quizLost );
  396.             $quizLost->setEleve( $this );
  397.         }
  399.         return $this;
  400.     }
  402.     public function removeQuizLost( QuizLost $quizLost ): self
  403.  {
  404.         if ( $this->quizLosts->removeElement( $quizLost ) ) {
  405.             // set the owning side to null ( unless already changed )
  406.             if ( $quizLost->getEleve() === $this ) {
  407.                 $quizLost->setEleve( null );
  408.             }
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.     * @return Collection<int, Evaluation>
  416.     */
  418.     public function getEvaluations(): Collection
  419.  {
  420.         return $this->evaluations;
  421.     }
  423.     public function addEvaluation( Evaluation $evaluation ): self
  424.  {
  425.         if ( !$this->evaluations->contains( $evaluation ) ) {
  426.             $this->evaluations->add( $evaluation );
  427.             $evaluation->addEleve( $this );
  428.         }
  430.         return $this;
  431.     }
  433.     public function removeEvaluation( Evaluation $evaluation ): self
  434.  {
  435.         if ( $this->evaluations->removeElement( $evaluation ) ) {
  436.             $evaluation->removeEleve( $this );
  437.         }
  439.         return $this;
  440.     }
  442.     /**
  443.     * @return Collection<int, EvaluationResultat>
  444.     */
  446.     public function getEvaluationResultats(): Collection
  447.  {
  448.         return $this->evaluationResultats;
  449.     }
  451.     public function addEvaluationResultat( EvaluationResultat $evaluationResultat ): self
  452.  {
  453.         if ( !$this->evaluationResultats->contains( $evaluationResultat ) ) {
  454.             $this->evaluationResultats->add( $evaluationResultat );
  455.             $evaluationResultat->setEleve( $this );
  456.         }
  458.         return $this;
  459.     }
  461.     public function removeEvaluationResultat( EvaluationResultat $evaluationResultat ): self
  462.  {
  463.         if ( $this->evaluationResultats->removeElement( $evaluationResultat ) ) {
  464.             // set the owning side to null ( unless already changed )
  465.             if ( $evaluationResultat->getEleve() === $this ) {
  466.                 $evaluationResultat->setEleve( null );
  467.             }
  468.         }
  470.         return $this;
  471.     }
  473.     public function getSkillLevel(): ?SkillLevel
  474.     {
  475.         return $this->classe ? $this->classe->getSkillLevel() : null;
  476.     }
  478.     /**
  479.      * @return Collection<int, SubjectChat>
  480.      */
  481.     public function getSubjectChats(): Collection
  482.     {
  483.         return $this->subjectChats;
  484.     }
  486.     public function addSubjectChat(SubjectChat $subjectChat): static
  487.     {
  488.         if (!$this->subjectChats->contains($subjectChat)) {
  489.             $this->subjectChats->add($subjectChat);
  490.             $subjectChat->setEleve($this);
  491.         }
  493.         return $this;
  494.     }
  496.     public function removeSubjectChat(SubjectChat $subjectChat): static
  497.     {
  498.         if ($this->subjectChats->removeElement($subjectChat)) {
  499.             // set the owning side to null (unless already changed)
  500.             if ($subjectChat->getEleve() === $this) {
  501.                 $subjectChat->setEleve(null);
  502.             }
  503.         }
  505.         return $this;
  506.     }
  507. }