src/Entity/User.php line 26

  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\DBAL\Types\Types;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Repository\UserRepository;
  8. use ApiPlatform\Metadata\ApiResource;
  9. use ApiPlatform\Metadata\ApiSubresource;
  10. use Doctrine\Common\Collections\Collection;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. use Symfony\Component\Validator\Constraints as Assert;
  19. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
  21. #[ORM\Entity(repositoryClass: UserRepository::class)]
  22. #[ApiResource(normalizationContext: ['groups' => ['user']])]
  23. #[UniqueEntity(fields: ['email'], message: 'Un compte existe déjà avec cet email')]
  24. #[UniqueEntity(fields: ['userName'], message: 'Ce pseudo est déjà utilisé')]
  25. #[ORM\HasLifecycleCallbacks()]
  26. class User implements UserInterface, PasswordAuthenticatedUserInterface
  27. {
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     #[Groups(["user"])]
  32.     private ?int $id = null;
  34.     #[ORM\Column(length: 180, unique: true)]
  35.     private ?string $email = null;
  37.     #[ORM\Column]
  38.     private array $roles = [];
  40.     /**
  41.      * @var string The hashed password
  42.      */
  43.     #[ORM\Column]
  44.     private ?string $password = null;
  46.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Objectif::class)]
  47.     #[Groups(["user"])]
  48.     private Collection $objectifs;
  50.     #[ORM\ManyToMany(targetEntity: Objectif::class, mappedBy: 'community')]
  51.     private Collection $joinObjectifs;
  53.     #[ORM\Column(length: 255, nullable: true)]
  54.     #[Groups(["user"])]
  55.     private ?string $userName = null;
  58.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  59.     private ?\DateTimeInterface $registerAt = null;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     #[Groups(["user"])]
  63.     private ?string $avatar = null;
  65.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  66.     private ?string $promesse = null;
  68.     #[ORM\Column(nullable: true)]
  69.     private ?bool $isPrivate = null;
  71.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: GameScore::class)]
  72.     private Collection $successPoints;
  74.     #[ORM\ManyToMany(targetEntity: self::class, inversedBy: 'users')]
  75.     private Collection $friends;
  77.     #[ORM\ManyToMany(targetEntity: self::class, mappedBy: 'friends')]
  78.     private Collection $users;
  80.     #[ORM\Column(nullable: true)]
  81.     private ?bool $isDailyMailEnabled = null;
  83.     #[ORM\Column(length: 255, nullable: true)]
  84.     private ?string $stripeId = null;
  86.     #[ORM\OneToOne(inversedBy: 'user', cascade: ['persist', 'remove'])]
  87.     private ?Subscription $subscription = null;
  90.     public function __construct()
  91.     {
  92.         $this->objectifs = new ArrayCollection();
  93.         $this->joinObjectifs = new ArrayCollection();
  94.         $this->successPoints = new ArrayCollection();
  95.         $this->friends = new ArrayCollection();
  96.         $this->users = new ArrayCollection();
  97.     }
  99.     #[ORM\PrePersist]
  100.     public function prePersist()
  101.     {
  102.         if (empty($this->registerAt)) {
  103.             $this->registerAt = new \DateTime();
  104.             $this->isDailyMailEnabled = true;
  105.         }
  106.     }
  108.     public function getId(): ?int
  109.     {
  110.         return $this->id;
  111.     }
  113.     public function getEmail(): ?string
  114.     {
  115.         return $this->email;
  116.     }
  118.     public function setEmail(string $email): self
  119.     {
  120.         $this->email = $email;
  122.         return $this;
  123.     }
  125.     public function __toString()
  126.     {
  127.         return strtoupper($this->email);
  128.     }
  131.     /**
  132.      * A visual identifier that represents this user.
  133.      *
  134.      * @see UserInterface
  135.      */
  136.     public function getUserIdentifier(): string
  137.     {
  138.         return (string) $this->email;
  139.     }
  141.     /**
  142.      * @see UserInterface
  143.      */
  144.     public function getRoles(): array
  145.     {
  146.         $roles = $this->roles;
  147.         // guarantee every user at least has ROLE_USER
  148.         $roles[] = 'ROLE_USER';
  150.         return array_unique($roles);
  151.     }
  153.     public function setRoles(array $roles): self
  154.     {
  155.         $this->roles = $roles;
  157.         return $this;
  158.     }
  160.     /**
  161.      * @see PasswordAuthenticatedUserInterface
  162.      */
  163.     public function getPassword(): string
  164.     {
  165.         return $this->password;
  166.     }
  168.     public function setPassword(string $password): self
  169.     {
  170.         $this->password = $password;
  172.         return $this;
  173.     }
  175.     /**
  176.      * @see UserInterface
  177.      */
  178.     public function eraseCredentials()
  179.     {
  180.         // If you store any temporary, sensitive data on the user, clear it here
  181.         // $this->plainPassword = null;
  182.     }
  184.     /**
  185.      * @return Collection<int, Objectif>
  186.      */
  187.     public function getObjectifs(): Collection
  188.     {
  189.         return $this->objectifs;
  190.     }
  192.     public function addObjectif(Objectif $objectif): self
  193.     {
  194.         if (!$this->objectifs->contains($objectif)) {
  195.             $this->objectifs->add($objectif);
  196.             $objectif->setUser($this);
  197.         }
  199.         return $this;
  200.     }
  202.     public function removeObjectif(Objectif $objectif): self
  203.     {
  204.         if ($this->objectifs->removeElement($objectif)) {
  205.             // set the owning side to null (unless already changed)
  206.             if ($objectif->getUser() === $this) {
  207.                 $objectif->setUser(null);
  208.             }
  209.         }
  211.         return $this;
  212.     }
  214.     /**
  215.      * @return Collection<int, Objectif>
  216.      */
  217.     public function getJoinObjectifs(): Collection
  218.     {
  219.         return $this->joinObjectifs;
  220.     }
  222.     public function addJoinObjectif(Objectif $joinObjectif): self
  223.     {
  224.         if (!$this->joinObjectifs->contains($joinObjectif)) {
  225.             $this->joinObjectifs->add($joinObjectif);
  226.             $joinObjectif->addCommunity($this);
  227.         }
  229.         return $this;
  230.     }
  232.     public function removeJoinObjectif(Objectif $joinObjectif): self
  233.     {
  234.         if ($this->joinObjectifs->removeElement($joinObjectif)) {
  235.             $joinObjectif->removeCommunity($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function getUserName(): ?string
  242.     {
  243.         return $this->userName;
  244.     }
  246.     public function setUserName(?string $userName): self
  247.     {
  248.         $this->userName = $userName;
  250.         return $this;
  251.     }
  253.     public function getRegisterAt(): ?\DateTimeInterface
  254.     {
  255.         return $this->registerAt;
  256.     }
  258.     public function setRegisterAt(\DateTimeInterface $registerAt): self
  259.     {
  260.         $this->registerAt = $registerAt;
  262.         return $this;
  263.     }
  265.     public function getAvatar(): ?string
  266.     {
  267.         return $this->avatar;
  268.     }
  270.     public function setAvatar(?string $avatar): self
  271.     {
  272.         $this->avatar = $avatar;
  274.         return $this;
  275.     }
  277.     public function getPromesse(): ?string
  278.     {
  279.         return $this->promesse;
  280.     }
  282.     public function setPromesse(?string $promesse): self
  283.     {
  284.         $this->promesse = $promesse;
  286.         return $this;
  287.     }
  289.     public function isIsPrivate(): ?bool
  290.     {
  291.         return $this->isPrivate;
  292.     }
  294.     public function setIsPrivate(?bool $isPrivate): self
  295.     {
  296.         $this->isPrivate = $isPrivate;
  298.         return $this;
  299.     }
  301.     /**
  302.      * @return Collection<int, GameScore>
  303.      */
  304.     public function getSuccessPoints(): Collection
  305.     {
  306.         return $this->successPoints;
  307.     }
  309.     public function addSuccessPoint(GameScore $successPoint): self
  310.     {
  311.         if (!$this->successPoints->contains($successPoint)) {
  312.             $this->successPoints->add($successPoint);
  313.             $successPoint->setUser($this);
  314.         }
  316.         return $this;
  317.     }
  319.     public function removeSuccessPoint(GameScore $successPoint): self
  320.     {
  321.         if ($this->successPoints->removeElement($successPoint)) {
  322.             // set the owning side to null (unless already changed)
  323.             if ($successPoint->getUser() === $this) {
  324.                 $successPoint->setUser(null);
  325.             }
  326.         }
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, self>
  333.      */
  334.     public function getFriends(): Collection
  335.     {
  336.         return $this->friends;
  337.     }
  339.     public function addFriend(self $friend): self
  340.     {
  341.         if (!$this->friends->contains($friend)) {
  342.             $this->friends->add($friend);
  343.         }
  345.         return $this;
  346.     }
  348.     public function removeFriend(self $friend): self
  349.     {
  350.         $this->friends->removeElement($friend);
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection<int, self>
  357.      */
  358.     public function getUsers(): Collection
  359.     {
  360.         return $this->users;
  361.     }
  363.     public function addUser(self $user): self
  364.     {
  365.         if (!$this->users->contains($user)) {
  366.             $this->users->add($user);
  367.             $user->addFriend($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removeUser(self $user): self
  374.     {
  375.         if ($this->users->removeElement($user)) {
  376.             $user->removeFriend($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function isIsDailyMailEnabled(): ?bool
  383.     {
  384.         return $this->isDailyMailEnabled;
  385.     }
  387.     public function setIsDailyMailEnabled(?bool $isDailyMailEnabled): self
  388.     {
  389.         $this->isDailyMailEnabled = $isDailyMailEnabled;
  391.         return $this;
  392.     }
  394.     public function getStripeId(): ?string
  395.     {
  396.         return $this->stripeId;
  397.     }
  399.     public function setStripeId(?string $stripeId): self
  400.     {
  401.         $this->stripeId = $stripeId;
  403.         return $this;
  404.     }
  406.     public function getSubscription(): ?Subscription
  407.     {
  408.         return $this->subscription;
  409.     }
  411.     public function setSubscription(?Subscription $subscription): self
  412.     {
  413.         $this->subscription = $subscription;
  415.         return $this;
  416.     }
  419. }