src/Entity/User.php line 24

Open in your IDE?
  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;
  12. use App\Entity\Categorie;
  13. use App\Entity\Article;
  14. use App\Entity\Post;
  19. #[ORM\Entity(repositoryClass: UserRepository::class)]
  20. #[ORM\Table(name: "user")]
  22. // montre que ce NOM user est UNIQUE
  23. #[UniqueEntity(fields: ['username'], message: 'Il existe déjà un compte avec ce nom d\'utilisateur')]
  24. class User implements UserInterface, PasswordAuthenticatedUserInterface
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(length: 180, unique: true)]
  32.     private ?string $username = null;
  34.     #[ORM\Column(length: 255)]
  35.     private ?string $email = null;
  36.     
  38.     #[ORM\Column]
  39.     private array $roles = [];
  41.     /**
  42.      * @var string 
  43.      */
  44.     #[ORM\Column]
  45.     private ?string $password = null;
  47.     #[ORM\Column(type: 'boolean')]
  48.     private $isVerified = false;
  50.     
  52.     
  53.     #[ORM\OneToMany(targetEntity: Message::class, mappedBy: 'expediteur', orphanRemoval: true)]
  54. private Collection $sentMessages;
  56. #[ORM\OneToMany(targetEntity: Message::class, mappedBy: 'destinataire', orphanRemoval: true)]
  57. private Collection $receivedMessages;
  59.     #[ORM\ManyToMany(targetEntity: self::class)]
  60.     #[ORM\JoinTable(
  61.         name: 'user_friends',
  62.         joinColumns: [new ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id')],
  63.         inverseJoinColumns: [new ORM\JoinColumn(name: 'friend_user_id', referencedColumnName: 'id')]
  64.     )]
  65.     private Collection $friends;
  67.     //RELATIONS Collection est une structure de donnée qui représente un groupe d'objet
  68.     #[ORM\OneToMany(targetEntity: Article::class, mappedBy: 'user', orphanRemoval: true)]
  69. private Collection $articles;
  71. // Pour Posts
  72. #[ORM\OneToMany(targetEntity: Post::class, mappedBy: 'user', orphanRemoval: true)]
  73. private Collection $posts;
  74.     
  75.     #[ORM\ManyToMany(targetEntity:User::class, mappedBy:"receivedFriendRequests")]
  76.     private $sentFriendRequests;
  79.     
  80.     #[ORM\ManyToMany(targetEntity:User::class, inversedBy:"sentFriendRequests")]
  81.       #[ORM\JoinTable(
  82.           name:"user_friend_requests",
  83.           joinColumns: [new ORM\JoinColumn(name:"sender_id", referencedColumnName:"id")],
  84.           inverseJoinColumns: [new ORM\JoinColumn(name:"receiver_id", referencedColumnName:"id")]
  85.       )]
  86.     private Collection $receivedFriendRequests;
  91.     //initialise articles et post
  92.     public function __construct()
  93.     {
  94.         /* ArrayCollection pour manipuler facilement ces collections */
  95.         $this->articles = new ArrayCollection();
  96.         $this->posts = new ArrayCollection();
  97.         $this->sentMessages = new ArrayCollection();
  98.         $this->receivedMessages = new ArrayCollection();
  99.         $this->friends = new ArrayCollection();
  100.         $this->myFriends = new ArrayCollection();
  101.         $this->sentFriendRequests = new ArrayCollection();
  102.         $this->receivedFriendRequests = new ArrayCollection();
  103.     }
  106.     /* FRIENDS */
  107.      /**
  108.      * @return Collection|User[]
  109.      */
  110.     public function getFriends(): Collection
  111.     {
  112.         return $this->friends;
  113.     }
  115.     public function addFriend(User $friend): self
  116.     {
  117.         if (!$this->friends->contains($friend)) {
  118.             $this->friends[] = $friend;
  119.         }
  120.         return $this;
  121.     }
  123.     public function removeFriend(User $friend): self
  124.     {
  125.         $this->friends->removeElement($friend);
  126.         return $this;
  127.     }
  131.     /* REQUETE DEMANDE AMI */
  132.     public function getSentFriendRequests(): Collection
  133.     {
  134.         return $this->sentFriendRequests;
  135.     }
  137.     public function addSentFriendRequest(User $user): self
  138.     {
  139.         if (!$this->sentFriendRequests->contains($user)) {
  140.             $this->sentFriendRequests[] = $user;
  141.         }
  142.         return $this;
  143.     }
  145.     public function removeSentFriendRequest(User $user): self
  146.     {
  147.         $this->sentFriendRequests->removeElement($user);
  149.         return $this;
  150.     }
  159.     /* MESSAGE ENVOYER */
  160.      /**
  161.      * @return Collection|Message[]
  162.      */
  163.     public function getSentMessages(): Collection
  164.     {
  165.         return $this->sentMessages;
  166.     }
  168.     public function addSentMessage(Message $sentMessage): self
  169.     {
  170.         if (!$this->sentMessages->contains($sentMessage)) {
  171.             $this->sentMessages[] = $sentMessage;
  172.             $sentMessage->setExpediteur($this);
  173.         }
  174.         return $this;
  175.     }
  177.     public function removeSentMessage(Message $sentMessage): self
  178.     {
  179.         if ($this->sentMessages->removeElement($sentMessage)) {
  180.             if ($sentMessage->getExpediteur() === $this) {
  181.                 $sentMessage->setExpediteur(null);
  182.             }
  183.         }
  185.         return $this;
  186.     }
  188.     /* RECEVOIR MESSAGE */
  189.     /**
  190.      * @return Collection|Message[]
  191.      */
  192.     public function getReceivedMessages(): Collection
  193.     {
  194.         return $this->receivedMessages;
  195.     }
  197.     public function addReceivedMessage(Message $receivedMessage): self
  198.     {
  199.         if (!$this->receivedMessages->contains($receivedMessage)) {
  200.             $this->receivedMessages[] = $receivedMessage;
  201.             $receivedMessage->setDestinataire($this);
  202.         }
  204.         return $this;
  205.     }
  207.     public function removeReceivedMessage(Message $receivedMessage): self
  208.     {
  209.         if ($this->receivedMessages->removeElement($receivedMessage)) {
  210.             if ($receivedMessage->getDestinataire() === $this) {
  211.                 $receivedMessage->setDestinataire(null);
  212.             }
  213.         }
  214.         return $this;
  215.     }
  219.     public function getId(): ?int
  220.     {
  221.         return $this->id;
  222.     }
  224.    
  225.     public function getEmail(): ?string
  226.     {
  227.         return $this->email;
  228.     }
  230.     public function setEmail(string $email): static
  231.     {
  232.         $this->email = $email;
  233.         return $this;
  234.     }
  236.     
  240.     public function setUsername(string $username): static
  241.     {
  242.         $this->username = $username;
  243.         return $this;
  244.     }
  247.     /**
  248.      * A visual identifier that represents this user.
  249.      *
  250.      * @see UserInterface
  251.      */
  252.     public function getUsername(): string
  253.     {
  254.         return (string) $this->username;
  255.     }
  261.     /**
  262.      * @see UserInterface
  263.      */
  264.     public function getRoles(): array
  265.     {
  266.         $roles = $this->roles;
  267.         return array_unique($roles);
  268.     }
  270.     public function setRoles(array $roles): static
  271.     {
  272.         $this->roles = $roles;
  273.         return $this;
  274.     }
  290.     
  291.     /**
  292.      * @see PasswordAuthenticatedUserInterface
  293.      */
  294.     public function getPassword(): string
  295.     {
  296.         return $this->password;
  297.     }
  299.     public function setPassword(string $password): static
  300.     {
  301.         $this->password = $password;
  302.         return $this;
  303.     }
  312.     public function getReceivedFriendRequests(): Collection
  313.     {
  314.         return $this->receivedFriendRequests;
  315.     }
  317.     public function addReceivedFriendRequest(User $user): self
  318.     {
  319.         if (!$this->receivedFriendRequests->contains($user)) {
  320.             $this->receivedFriendRequests[] = $user;
  321.         }
  322.         return $this;
  323.     }
  325.     public function removeReceivedFriendRequest(User $user): self
  326.     {
  327.         $this->receivedFriendRequests->removeElement($user);
  328.         return $this;
  329.     }
  338.     
  339.     /**
  340.      *  "salt" est un algorithme de hachage moderne pour MDP dans votre fichier security.yaml.
  341.     *
  342.      * @see UserInterface
  343.      */
  344.     public function getSalt(): ?string
  345.     {
  346.         return null;
  347.     }
  349.     /* Ajouter par symfony afin d'effacer tt donnée apres authentification */
  350.     /**
  351.      * @see UserInterface
  352.      */
  353.     public function eraseCredentials(): void
  354.     {
  355.         // If you store any temporary, sensitive data on the user, clear it here
  356.         // $this->plainPassword = null;
  357.     }
  360.     
  362.     public function isVerified(): bool
  363.     {
  364.         return $this->isVerified;
  365.     }
  367.     public function setIsVerified(bool $isVerified): static
  368.     {
  369.         $this->isVerified = $isVerified;
  370.         return $this;
  371.     }
  373.     /*ARTICLE  */
  374.     /**
  375.      * @return Collection<int, Article>
  376.      */
  377.     public function getArticles(): Collection
  378.     {
  379.         return $this->articles;
  380.     }
  382.     public function addArticle(Article $article): static
  383.     {
  384.         if (!$this->articles->contains($article)) {
  385.             $this->articles->add($article);
  386.             $article->setUser($this);
  387.         }
  388.         return $this;
  389.     }
  391.     public function removeArticle(Article $article): static
  392.     {
  393.         if ($this->articles->removeElement($article)) {
  394.             if ($article->getUser() === $this) {
  395.                 $article->setUser(null);
  396.             }
  397.         }
  398.         return $this;
  399.     }
  405.     /**
  406.      * @return Collection<int, Post>
  407.      */
  408.     public function getPosts(): Collection
  409.     {
  410.         return $this->posts;
  411.     }
  413.     public function addPost(Post $post): static
  414.     {
  415.         if (!$this->posts->contains($post)) {
  416.             $this->posts->add($post);
  417.             $post->setUser($this);
  418.         }
  419.         return $this;
  420.     }
  422.     public function removePost(Post $post): static
  423.     {
  424.         if ($this->posts->removeElement($post)) {
  425.             if ($post->getUser() === $this) {
  426.                 $post->setUser(null);
  427.             }
  428.         }
  429.         return $this;
  430.     }
  431. }