src/Entity/User.php line 17

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  13. /**
  14.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  15.  */
  16. #[ORM\Entity(repositoryClass: UserRepository::class)]
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column(type: 'integer')]
  22.     private $id;
  24.     #[ORM\Column(type: 'string', length: 255)]
  25.     private $nickname;
  26.     
  27.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  28.     private $email;
  30.     #[ORM\Column(type: 'json')]
  31.     private $roles = [];
  33.     const ROLES = array(
  34.         'Administrateur' => 'ROLE_FATHER',
  35.         'Maître de jeu' => 'ROLE_MASTER',
  36.         'Joueur' => 'ROLE_USER'
  37.     );
  39.     #[ORM\Column(type: 'string')]
  40.     private $password;
  44.     /**
  45.      * @ORM\Column(type="boolean")
  46.      */
  47.     private $isVerified = false;
  49.     #[ORM\OneToMany(mappedBy: 'player', targetEntity: PlayableEntity::class)]
  50.     private $playableEntities;
  52.     #[ORM\OneToOne(inversedBy: 'user', targetEntity: PlayableEntity::class, cascade: ['persist', 'remove'])]
  53.     private $character;
  55.     #[ORM\Column(length: 255, nullable: true)]
  56.     private ?string $avatar = null;
  58.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  59.     private ?Image $image = null;
  61.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: UserMessage::class)]
  62.     private Collection $sent;
  64.     #[ORM\OneToMany(mappedBy: 'recipient', targetEntity: UserMessage::class)]
  65.     private Collection $received;
  67.     public function __construct()
  68.     {
  69.         $this->playableEntities = new ArrayCollection();
  70.         $this->sent = new ArrayCollection();
  71.         $this->received = new ArrayCollection();
  72.     }
  74.     public function getId(): ?int
  75.     {
  76.         return $this->id;
  77.     }
  79.     public function getEmail(): ?string
  80.     {
  81.         return $this->email;
  82.     }
  84.     public function setEmail(string $email): self
  85.     {
  86.         $this->email = $email;
  88.         return $this;
  89.     }
  91.     /**
  92.      * A visual identifier that represents this user.
  93.      *
  94.      * @see UserInterface
  95.      */
  96.     public function getUserIdentifier(): string
  97.     {
  98.         return (string) $this->email;
  99.     }
  101.     /**
  102.      * @see UserInterface
  103.      */
  104.     public function getRoles(): array
  105.     {
  106.         $roles = $this->roles;
  107.         // guarantee every user at least has ROLE_USER
  108.         $roles[] = 'ROLE_USER';
  110.         return array_unique($roles);
  111.     }
  113.     public function setRoles(array $roles): self
  114.     {
  115.         $this->roles = $roles;
  117.         return $this;
  118.     }
  120.     /**
  121.      * @see PasswordAuthenticatedUserInterface
  122.      */
  123.     public function getPassword(): string
  124.     {
  125.         return $this->password;
  126.     }
  128.     public function setPassword(string $password): self
  129.     {
  130.         $this->password = $password;
  132.         return $this;
  133.     }
  135.     /**
  136.      * @see UserInterface
  137.      */
  138.     public function eraseCredentials()
  139.     {
  140.         // If you store any temporary, sensitive data on the user, clear it here
  141.         // $this->plainPassword = null;
  142.     }
  144.     public function getNickname(): ?string
  145.     {
  146.         return $this->nickname;
  147.     }
  149.     public function setNickname(string $nickname): self
  150.     {
  151.         $this->nickname = $nickname;
  153.         return $this;
  154.     }
  156.     public function isVerified(): bool
  157.     {
  158.         return $this->isVerified;
  159.     }
  161.     public function setIsVerified(bool $isVerified): self
  162.     {
  163.         $this->isVerified = $isVerified;
  165.         return $this;
  166.     }
  168.     /**
  169.      * @return Collection|PlayableEntity[]
  170.      */
  171.     public function getPlayableEntities(): Collection
  172.     {
  173.         return $this->playableEntities;
  174.     }
  176.     public function addPlayableEntity(PlayableEntity $playableEntity): self
  177.     {
  178.         if (!$this->playableEntities->contains($playableEntity)) {
  179.             $this->playableEntities[] = $playableEntity;
  180.             $playableEntity->setPlayer($this);
  181.         }
  183.         return $this;
  184.     }
  186.     public function removePlayableEntity(PlayableEntity $playableEntity): self
  187.     {
  188.         if ($this->playableEntities->removeElement($playableEntity)) {
  189.             // set the owning side to null (unless already changed)
  190.             if ($playableEntity->getPlayer() === $this) {
  191.                 $playableEntity->setPlayer(null);
  192.             }
  193.         }
  195.         return $this;
  196.     }
  198.     public function __toString()
  199.     {
  200.         return (string) $this->nickname;
  201.     }
  203.     public function getCharacter(): ?PlayableEntity
  204.     {
  205.         return $this->character;
  206.     }
  208.     public function setCharacter(?PlayableEntity $character): self
  209.     {
  210.         $this->character = $character;
  212.         return $this;
  213.     }
  215.     public function getAvatar(): ?string
  216.     {
  217.         return $this->avatar;
  218.     }
  220.     public function setAvatar(?string $avatar): self
  221.     {
  222.         $this->avatar = $avatar;
  224.         return $this;
  225.     }
  227.     public function getImage(): ?Image
  228.     {
  229.         return $this->image;
  230.     }
  232.     public function setImage(?Image $image): self
  233.     {
  234.         // unset the owning side of the relation if necessary
  235.         if ($image === null && $this->image !== null) {
  236.             $this->image->setUser(null);
  237.         }
  239.         // set the owning side of the relation if necessary
  240.         if ($image !== null && $image->getUser() !== $this) {
  241.             $image->setUser($this);
  242.         }
  244.         $this->image = $image;
  246.         return $this;
  247.     }
  249.     /**
  250.      * @return Collection<int, UserMessage>
  251.      */
  252.     public function getSent(): Collection
  253.     {
  254.         return $this->sent;
  255.     }
  257.     public function addSent(UserMessage $sent): self
  258.     {
  259.         if (!$this->sent->contains($sent)) {
  260.             $this->sent->add($sent);
  261.             $sent->setSender($this);
  262.         }
  264.         return $this;
  265.     }
  267.     public function removeSent(UserMessage $sent): self
  268.     {
  269.         if ($this->sent->removeElement($sent)) {
  270.             // set the owning side to null (unless already changed)
  271.             if ($sent->getSender() === $this) {
  272.                 $sent->setSender(null);
  273.             }
  274.         }
  276.         return $this;
  277.     }
  279.     /**
  280.      * @return Collection<int, UserMessage>
  281.      */
  282.     public function getReceived(): Collection
  283.     {
  284.         return $this->received;
  285.     }
  287.     public function addReceived(UserMessage $received): self
  288.     {
  289.         if (!$this->received->contains($received)) {
  290.             $this->received->add($received);
  291.             $received->setRecipient($this);
  292.         }
  294.         return $this;
  295.     }
  297.     public function removeReceived(UserMessage $received): self
  298.     {
  299.         if ($this->received->removeElement($received)) {
  300.             // set the owning side to null (unless already changed)
  301.             if ($received->getRecipient() === $this) {
  302.                 $received->setRecipient(null);
  303.             }
  304.         }
  306.         return $this;
  307.     }
  308. }