src/Entity/User.php line 61

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\Get;
  7. use ApiPlatform\Metadata\Post;
  8. use ApiPlatform\Metadata\Put;
  9. use App\Controller\Api\Controller\User\MeController;
  10. use App\Repository\UserRepository;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  15. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  16. use Symfony\Component\Security\Core\User\UserInterface;
  17. use Symfony\Component\Serializer\Annotation\Groups;
  18. use Symfony\Component\Validator\Constraints as Assert;
  19. use Symfony\Component\Validator\Constraints\Valid;
  21. #[ORM\Entity(repositoryClass: UserRepository::class)]
  22. #[ORM\Table(name: 'kulmapeck_user')]
  23. #[UniqueEntity(fields: ['username'], message: 'Ce nom d\'utilisateur est déjà utilisé.')]
  24. #[UniqueEntity(fields: ['phoneNumber'], message: 'Ce numéro de téléphone est déjà utilisé.')]
  25. #[ORM\EntityListeners(['App\EntityListener\UserListener'])]
  26. #[ORM\HasLifecycleCallbacks]
  27. #[ApiResource(
  28.     operations: [
  29.         new Post(
  30.             denormalizationContext: [
  31.                 'groups' => ['post:user:item']
  32.             ],
  33.         ),
  34.         new Get(
  35.             normalizationContext: [
  36.                 'groups' => ['post:user:item', 'read:user:item']
  37.             ],
  38.         ),
  39.         new Get(
  40.             paginationEnabled: false,
  41.             uriTemplate: '/me',
  42.             controller: MeController::class,
  43.             read: false,
  44.             normalizationContext: [
  45.                 'groups' => ['read:user:item', 'post:user:item', 'read:personne:item']
  46.             ],
  47.             openapiContext: [
  48.                 'security' => [[ 'bearerAuth' => [] ]]
  49.             ]
  50.         ),
  51.         new Put(
  52.             denormalizationContext: [
  53.                 'groups' => ['post:user:item']
  54.             ],
  55.         ),
  56.     ],
  57.     normalizationContext: [
  58.         'groups' => ['read:user:item']
  59.     ],
  60. )]
  61. class User implements UserInterface, PasswordAuthenticatedUserInterface
  62. {
  63.     #[ORM\Id]
  64.     #[ORM\GeneratedValue]
  65.     #[ORM\Column]
  66.     #[Groups(['read:course:collection', 'read:forum:item', 'read:forum:messsage:collection', 'read:sujet:item', 'read:sujet:collection', 'read:exam:collection', 'read:user:item', 'read:payment:collection', 'read:review:collection'])]
  67.     private ?int $id = null;
  69.     #[ORM\Column(length: 180, nullable: true)]
  70.     #[Assert\Email(message: "L'email {{ value }} n'est pas une adresse e-mail valide !")]
  71.     #[Groups(['read:course:collection', 'read:sujet:collection', 'post:user:item', 'post:user:item', 'read:payment:collection', 'read:review:collection'])]
  72.     private ?string $email = null;
  74.     #[ORM\Column(length: 180, unique: true)]
  75.     #[Groups(['read:course:collection', 'read:sujet:collection', 'post:user:item', 'read:payment:collection', 'read:review:collection'])]
  76.     private ?string $username = null;
  78.     #[ORM\Column(length: 180, unique: true, nullable: true)]
  79.     #[Groups(['read:course:collection', 'read:sujet:collection', 'post:user:item', 'read:payment:collection', 'read:review:collection'])]
  80.     private ?string $phoneNumber = null;
  82.     #[ORM\Column]
  83.     #[Groups(['read:user:item'])]
  84.     private array $roles = [];
  86.     /**
  87.      * @var string The hashed password
  88.      */
  89.     #[ORM\Column]
  90.     #[Groups(['post:user:item'])]
  91.     private ?string $password = null;
  93.     #[ORM\OneToMany(mappedBy: 'destinataire', targetEntity: Notification::class, orphanRemoval: true)]
  94.     private Collection $notifications;
  96.     #[ORM\OneToOne(mappedBy: 'utilisateur', cascade: ['persist', 'remove'])]
  97.     #[Groups(['read:course:collection', 'post:user:item'])]
  98.     #[Valid()]
  99.     private ?Eleve $eleve = null;
  101.     #[ORM\OneToOne(mappedBy: 'utilisateur', cascade: ['persist', 'remove'])]
  102.     private ?Enseignant $enseignant = null;
  104.     #[ORM\OneToMany(mappedBy: 'author', targetEntity: Like::class, orphanRemoval: true)]
  105.     private Collection $likes;
  107.     #[ORM\Column(type: 'boolean')]
  108.     private ?bool $isVerified = false;
  110.     #[Groups(['post:user:item'])]
  111.     public ?string $parentCode = null;
  113.     #[ORM\OneToOne(mappedBy: 'utilisateur', cascade: ['persist', 'remove'])]
  114.     #[Groups(['read:course:collection', 'read:personne:item', 'read:sujet:item', 'read:sujet:collection', 'read:review:collection', 'read:exam:collection', 'post:user:item', 'read:payment:collection', 'read:quizresult:collection'])]
  115.     #[Valid()]
  116.     private ?Personne $personne = null;
  118.     #[ORM\Column(nullable: true)]
  119.     #[Groups(['read:user:item', 'read:review:collection'])]
  120.     private ?bool $isBlocked = null;
  122.     #[ORM\Column(nullable: true)]
  123.     #[Groups(['read:user:item', 'read:review:collection'])]
  124.     private ?bool $isAdmin = null;
  126.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Exam::class)]
  127.     private Collection $exams;
  129.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: NotificationSetting::class, orphanRemoval: true)]
  130.     private Collection $notificationSettings;
  132.     #[ORM\ManyToMany(targetEntity: Filiere::class, inversedBy: 'users')]
  133.     private Collection $filieres;
  135.     #[ORM\Column(nullable: true)]
  136.     #[Groups(['read:user:item'])]
  138.     private ?float $points = null;
  140.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Retrait::class, orphanRemoval: true)]
  141.     #[Groups(['read:user:item', 'read:retraits:collection'])]
  143.     private Collection $retraits;
  145.     #[ORM\Column]
  146.     #[Groups(['read:user:item'])]
  148.     private ?float $especes = null;
  150.     #[ORM\OneToMany(mappedBy: 'deviceToken', targetEntity: Device::class)]
  151.     private Collection $devices;
  153.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Contact::class)]
  154.     private Collection $contacts;
  156.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: MessageChat::class, orphanRemoval: true)]
  157.     private Collection $messageChats;
  159.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: WebSocketConnection::class, orphanRemoval: true)]
  160.     private Collection $webSocketConnections;
  162.     public function __construct()
  163.     {
  164.         $this->roles = [];
  165.         $this->notifications = new ArrayCollection();
  166.         $this->likes = new ArrayCollection();
  167.         $this->exams = new ArrayCollection();
  168.         $this->notificationSettings = new ArrayCollection();
  169.         $this->filieres = new ArrayCollection();
  170.         $this->retraits = new ArrayCollection();
  171.         $this->especes = 0;
  172.         $this->points = 0;
  173.         $this->isBlocked = false;
  174.         $this->isVerified = false;
  175.         $this->isAdmin = false;
  176.         $this->devices = new ArrayCollection();
  177.         $this->contacts = new ArrayCollection();
  178.         $this->messageChats = new ArrayCollection();
  179.         $this->webSocketConnections = new ArrayCollection();
  180.        
  181.     }
  183.     public function getId(): ?int
  184.     {
  185.         return $this->id;
  186.     }
  188.     public function getEmail(): ?string
  189.     {
  190.         return $this->email;
  191.     }
  193.     public function setEmail(string $email): self
  194.     {
  195.         $this->email = $email;
  197.         return $this;
  198.     }
  200.     public function getUsername(): ?string
  201.     {
  202.         return $this->username;
  203.     }
  205.     public function setUsername(string $username): self
  206.     {
  207.         $this->username = $username;
  209.         return $this;
  210.     }
  212.     public function getPhoneNumber(): ?string
  213.     {
  214.         return $this->phoneNumber;
  215.     }
  217.     public function setPhoneNumber(?string $phoneNumber): self
  218.     {
  219.         $this->phoneNumber = $phoneNumber;
  221.         return $this;
  222.     }
  224.     /**
  225.      * A visual identifier that represents this user.
  226.      *
  227.      * @see UserInterface
  228.      */
  230.     public function getUserIdentifier(): string
  231.     {
  232.         return (string) $this->username;
  233.     }
  235.     /**
  236.      * @see UserInterface
  237.      */
  239.     public function getRoles(): array
  240.     {
  241.         $roles = $this->roles;
  242.         // guarantee every user at least has ROLE_USER
  243.         $roles[] = 'ROLE_USER';
  245.         return array_unique($roles);
  246.     }
  248.     public function setRoles(array $roles): self
  249.     {
  250.         $this->roles = $roles;
  252.         return $this;
  253.     }
  255.     public function addRole(string $role): self
  256.     {
  257.         $this->roles[] = $role;
  259.         return $this;
  260.     }
  262.     /**
  263.      * @see PasswordAuthenticatedUserInterface
  264.      */
  266.     public function getPassword(): string
  267.     {
  268.         return $this->password;
  269.     }
  271.     public function setPassword(string $password): self
  272.     {
  273.         $this->password = $password;
  275.         return $this;
  276.     }
  278.     /**
  279.      * @see UserInterface
  280.      */
  282.     public function eraseCredentials()
  283.     {
  284.         // If you store any temporary, sensitive data on the user, clear it here
  285.         // $this->plainPassword = null;
  286.     }
  288.     /**
  289.      * @return Collection<int, Notification>
  290.      */
  292.     public function getNotifications(): Collection
  293.     {
  294.         return $this->notifications;
  295.     }
  297.     public function addNotification(Notification $notification): self
  298.     {
  299.         if (!$this->notifications->contains($notification)) {
  300.             $this->notifications->add($notification);
  301.             $notification->setDestinataire($this);
  302.         }
  304.         return $this;
  305.     }
  307.     public function removeNotification(Notification $notification): self
  308.     {
  309.         if ($this->notifications->removeElement($notification)) {
  310.             // set the owning side to null ( unless already changed )
  311.             if ($notification->getDestinataire() === $this) {
  312.                 $notification->setDestinataire(null);
  313.             }
  314.         }
  316.         return $this;
  317.     }
  319.     public function getEleve(): ?Eleve
  320.     {
  321.         return $this->eleve;
  322.     }
  324.     public function setEleve(Eleve $eleve): self
  325.     {
  326.         // set the owning side of the relation if necessary
  327.         if ($eleve->getUtilisateur() !== $this) {
  328.             $eleve->setUtilisateur($this);
  329.         }
  331.         $this->eleve = $eleve;
  333.         return $this;
  334.     }
  336.     public function getEnseignant(): ?Enseignant
  337.     {
  338.         return $this->enseignant;
  339.     }
  341.     public function setEnseignant(Enseignant $enseignant): self
  342.     {
  343.         // set the owning side of the relation if necessary
  344.         if ($enseignant->getUtilisateur() !== $this) {
  345.             $enseignant->setUtilisateur($this);
  346.         }
  348.         $this->enseignant = $enseignant;
  350.         return $this;
  351.     }
  353.     /**
  354.      * @return Collection<int, Like>
  355.      */
  357.     public function getLikes(): Collection
  358.     {
  359.         return $this->likes;
  360.     }
  362.     public function addLike(Like $like): self
  363.     {
  364.         if (!$this->likes->contains($like)) {
  365.             $this->likes->add($like);
  366.             $like->setAuthor($this);
  367.         }
  369.         return $this;
  370.     }
  372.     public function removeLike(Like $like): self
  373.     {
  374.         if ($this->likes->removeElement($like)) {
  375.             // set the owning side to null ( unless already changed )
  376.             if ($like->getAuthor() === $this) {
  377.                 $like->setAuthor(null);
  378.             }
  379.         }
  381.         return $this;
  382.     }
  384.     public function isVerified(): bool
  385.     {
  386.         return $this->isVerified;
  387.     }
  389.     public function setIsVerified(bool $isVerified): self
  390.     {
  391.         $this->isVerified = $isVerified;
  393.         return $this;
  394.     }
  396.     public function getPersonne(): ?Personne
  397.     {
  398.         return $this->personne;
  399.     }
  401.     public function setPersonne(?Personne $personne): self
  402.     {
  403.         $this->personne = $personne;
  405.         return $this;
  406.     }
  408.     public function isIsBlocked(): ?bool
  409.     {
  410.         return $this->isBlocked;
  411.     }
  413.     public function setIsBlocked(?bool $isBlocked): self
  414.     {
  415.         $this->isBlocked = $isBlocked;
  417.         return $this;
  418.     }
  420.     public function isIsAdmin(): ?bool
  421.     {
  422.         return $this->isAdmin;
  423.     }
  425.     public function setIsAdmin(?bool $isAdmin): self
  426.     {
  427.         $this->isAdmin = $isAdmin;
  429.         return $this;
  430.     }
  432.     /**
  433.      * @return Collection<int, Exam>
  434.      */
  436.     public function getExams(): Collection
  437.     {
  438.         return $this->exams;
  439.     }
  441.     public function addExam(Exam $exam): self
  442.     {
  443.         if (!$this->exams->contains($exam)) {
  444.             $this->exams->add($exam);
  445.             $exam->setUser($this);
  446.         }
  448.         return $this;
  449.     }
  451.     public function removeExam(Exam $exam): self
  452.     {
  453.         if ($this->exams->removeElement($exam)) {
  454.             // set the owning side to null ( unless already changed )
  455.             if ($exam->getUser() === $this) {
  456.                 $exam->setUser(null);
  457.             }
  458.         }
  460.         return $this;
  461.     }
  463.     /**
  464.      * @return Collection<int, NotificationSetting>
  465.      */
  467.     public function getNotificationSettings(): Collection
  468.     {
  469.         return $this->notificationSettings;
  470.     }
  472.     public function addNotificationSetting(NotificationSetting $notificationSetting): self
  473.     {
  474.         if (!$this->notificationSettings->contains($notificationSetting)) {
  475.             $this->notificationSettings->add($notificationSetting);
  476.             $notificationSetting->setUser($this);
  477.         }
  479.         return $this;
  480.     }
  482.     public function removeNotificationSetting(NotificationSetting $notificationSetting): self
  483.     {
  484.         if ($this->notificationSettings->removeElement($notificationSetting)) {
  485.             // set the owning side to null ( unless already changed )
  486.             if ($notificationSetting->getUser() === $this) {
  487.                 $notificationSetting->setUser(null);
  488.             }
  489.         }
  491.         return $this;
  492.     }
  494.     /**
  495.      * @return Collection<int, Filiere>
  496.      */
  498.     public function getFilieres(): Collection
  499.     {
  500.         return $this->filieres;
  501.     }
  503.     public function addFiliere(Filiere $filiere): self
  504.     {
  505.         if (!$this->filieres->contains($filiere)) {
  506.             $this->filieres->add($filiere);
  507.         }
  509.         return $this;
  510.     }
  512.     public function removeFiliere(Filiere $filiere): self
  513.     {
  514.         $this->filieres->removeElement($filiere);
  516.         return $this;
  517.     }
  519.     public function getPoints(): ?float
  520.     {
  521.         return $this->points;
  522.     }
  524.     public function setPoints(?float $points): static
  525.     {
  526.         $this->points = $points;
  528.         return $this;
  529.     }
  531.     /**
  532.      * @return Collection<int, Retrait>
  533.      */
  535.     public function getRetraits(): Collection
  536.     {
  537.         return $this->retraits;
  538.     }
  540.     public function addRetrait(Retrait $retrait): static
  541.     {
  542.         if (!$this->retraits->contains($retrait)) {
  543.             $this->retraits->add($retrait);
  544.             $retrait->setUser($this);
  545.         }
  547.         return $this;
  548.     }
  550.     public function removeRetrait(Retrait $retrait): static
  551.     {
  552.         if ($this->retraits->removeElement($retrait)) {
  553.             // set the owning side to null ( unless already changed )
  554.             if ($retrait->getUser() === $this) {
  555.                 $retrait->setUser(null);
  556.             }
  557.         }
  559.         return $this;
  560.     }
  562.     public function getEspeces(): ?float
  563.     {
  564.         return $this->especes;
  565.     }
  567.     public function setEspeces(float $especes): static
  568.     {
  569.         $this->especes = $especes;
  571.         return $this;
  572.     }
  574.     /**
  575.      * @return Collection<int, Device>
  576.      */
  578.     public function getDevices(): Collection
  579.     {
  580.         return $this->devices;
  581.     }
  583.     public function addDevice(Device $device): static
  584.     {
  585.         if (!$this->devices->contains($device)) {
  586.             $this->devices->add($device);
  587.             $device->setDeviceToken($this);
  588.         }
  590.         return $this;
  591.     }
  593.     public function removeDevice(Device $device): static
  594.     {
  595.         if ($this->devices->removeElement($device)) {
  596.             // set the owning side to null ( unless already changed )
  597.             if ($device->getDeviceToken() === $this) {
  598.                 $device->setDeviceToken(null);
  599.             }
  600.         }
  602.         return $this;
  603.     }
  605.     /**
  606.      * @return Collection<int, Contact>
  607.      */
  609.     public function getContacts(): Collection
  610.     {
  611.         return $this->contacts;
  612.     }
  614.     public function addContact(Contact $contact): static
  615.     {
  616.         if (!$this->contacts->contains($contact)) {
  617.             $this->contacts->add($contact);
  618.             $contact->setUser($this);
  619.         }
  621.         return $this;
  622.     }
  624.     public function removeContact(Contact $contact): static
  625.     {
  626.         if ($this->contacts->removeElement($contact)) {
  627.             // set the owning side to null ( unless already changed )
  628.             if ($contact->getUser() === $this) {
  629.                 $contact->setUser(null);
  630.             }
  631.         }
  633.         return $this;
  634.     }
  636.     public function __toString()
  637.     {
  638.         return $this->getPersonne()->getNomComplet();
  639.         // Or any other property that represents the user as a string
  640.     }
  642.     /**
  643.      * @return Collection<int, MessageChat>
  644.      */
  645.     public function getMessageChats(): Collection
  646.     {
  647.         return $this->messageChats;
  648.     }
  650.     public function addMessageChat(MessageChat $messageChat): static
  651.     {
  652.         if (!$this->messageChats->contains($messageChat)) {
  653.             $this->messageChats->add($messageChat);
  654.             $messageChat->setSender($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removeMessageChat(MessageChat $messageChat): static
  661.     {
  662.         if ($this->messageChats->removeElement($messageChat)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($messageChat->getSender() === $this) {
  665.                 $messageChat->setSender(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     /**
  673.      * @return Collection<int, WebSocketConnection>
  674.      */
  675.     public function getWebSocketConnections(): Collection
  676.     {
  677.         return $this->webSocketConnections;
  678.     }
  680.     public function addWebSocketConnection(WebSocketConnection $webSocketConnection): static
  681.     {
  682.         if (!$this->webSocketConnections->contains($webSocketConnection)) {
  683.             $this->webSocketConnections->add($webSocketConnection);
  684.             $webSocketConnection->setUser($this);
  685.         }
  687.         return $this;
  688.     }
  690.     public function removeWebSocketConnection(WebSocketConnection $webSocketConnection): static
  691.     {
  692.         if ($this->webSocketConnections->removeElement($webSocketConnection)) {
  693.             // set the owning side to null (unless already changed)
  694.             if ($webSocketConnection->getUser() === $this) {
  695.                 $webSocketConnection->setUser(null);
  696.             }
  697.         }
  699.         return $this;
  700.     }
  703. }