src/Entity/User.php line 16

  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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Gedmo\Timestampable\Traits\TimestampableEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(UserRepository::class)]
  15. #[ORM\Table('`user`')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     use TimestampableEntity;
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column]
  23.     private ?int $id;
  25.     #[ORM\Column(length: 180, unique: true)]
  26.     private ?string $email;
  28.     #[ORM\Column(type: Types::JSON)]
  29.     private array $roles = [];
  31.     /**
  32.      * The hashed password
  33.      */
  34.     #[ORM\Column]
  35.     private ?string $password;
  37.     /**
  38.      * The plain non-persisted password
  39.      */
  40.     private ?string $plainPassword;
  42.     #[ORM\Column]
  43.     private bool $enabled = true;
  45.     #[ORM\Column]
  46.     private ?string $firstName;
  48.     #[ORM\Column]
  49.     private ?string $lastName;
  51.     #[ORM\Column(nullable: true)]
  52.     private ?string $avatar;
  54.     #[ORM\OneToMany('askedBy', Question::class)]
  55.     private Collection $questions;
  57.     #[ORM\OneToMany('answeredBy', Answer::class)]
  58.     private Collection $answers;
  60.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Comment::class, orphanRemoval: true)]
  61.     private Collection $comments;
  65.     public function __construct()
  66.     {
  67.         $this->questions = new ArrayCollection();
  68.         $this->answers = new ArrayCollection();
  69.         $this->comments = new ArrayCollection();
  70.     }
  72.     public function __toString(): string
  73.     {
  74.         return $this->getFullName();
  75.     }
  77.     public function getId(): ?int
  78.     {
  79.         return $this->id;
  80.     }
  82.     public function getEmail(): ?string
  83.     {
  84.         return $this->email;
  85.     }
  87.     public function setEmail(string $email): self
  88.     {
  89.         $this->email = $email;
  91.         return $this;
  92.     }
  94.     /**
  95.      * A visual identifier that represents this user.
  96.      *
  97.      * @see UserInterface
  98.      */
  99.     public function getUserIdentifier(): string
  100.     {
  101.         return (string) $this->email;
  102.     }
  104.     /**
  105.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  106.      */
  107.     public function getUsername(): string
  108.     {
  109.         return (string) $this->email;
  110.     }
  112.     /**
  113.      * @see UserInterface
  114.      */
  115.     public function getRoles(): array
  116.     {
  117.         $roles = $this->roles;
  118.         // guarantee every user at least has ROLE_USER
  119.         $roles[] = 'ROLE_USER';
  121.         return array_unique($roles);
  122.     }
  124.     public function setRoles(array $roles): self
  125.     {
  126.         $this->roles = $roles;
  128.         return $this;
  129.     }
  131.     /**
  132.      * @see PasswordAuthenticatedUserInterface
  133.      */
  134.     public function getPassword(): string
  135.     {
  136.         return $this->password;
  137.     }
  139.     public function setPassword(string $password): self
  140.     {
  141.         $this->password = $password;
  143.         return $this;
  144.     }
  146.     public function getPlainPassword(): string
  147.     {
  148.         return $this->plainPassword;
  149.     }
  151.     public function setPlainPassword(string $plainPassword): void
  152.     {
  153.         $this->plainPassword = $plainPassword;
  154.     }
  156.     /**
  157.      * Returning a salt is only needed, if you are not using a modern
  158.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  159.      *
  160.      * @see UserInterface
  161.      */
  162.     public function getSalt(): ?string
  163.     {
  164.         return null;
  165.     }
  167.     /**
  168.      * @see UserInterface
  169.      */
  170.     public function eraseCredentials()
  171.     {
  172.         // If you store any temporary, sensitive data on the user, clear it here
  173.          $this->plainPassword = null;
  174.     }
  176.     public function isEnabled(): bool
  177.     {
  178.         return $this->enabled;
  179.     }
  181.     public function setEnabled(bool $enabled): void
  182.     {
  183.         $this->enabled = $enabled;
  184.     }
  186.     public function getFirstName(): ?string
  187.     {
  188.         return $this->firstName;
  189.     }
  191.     public function setFirstName(string $firstName): void
  192.     {
  193.         $this->firstName = $firstName;
  194.     }
  196.     public function getLastName(): ?string
  197.     {
  198.         return $this->lastName;
  199.     }
  201.     public function setLastName(string $lastName): void
  202.     {
  203.         $this->lastName = $lastName;
  204.     }
  206.     public function getFullName(): ?string
  207.     {
  208.         return $this->firstName.' '.$this->lastName;
  209.     }
  211.     public function getAvatar(): ?string
  212.     {
  213.         return $this->avatar;
  214.     }
  216.     public function getAvatarUrl(): ?string
  217.     {
  218.         if (!$this->avatar) {
  219.             return null;
  220.         }
  222.         if (strpos($this->avatar, '/') !== false) {
  223.             return $this->avatar;
  224.         }
  226.         return sprintf('/uploads/avatars/%s', $this->avatar);
  227.     }
  229.     public function setAvatar(?string $avatar): void
  230.     {
  231.         $this->avatar = $avatar;
  232.     }
  234.     /**
  235.      * @return Collection|Question[]
  236.      */
  237.     public function getQuestions(): Collection
  238.     {
  239.         return $this->questions;
  240.     }
  242.     public function addQuestion(Question $question): self
  243.     {
  244.         if (!$this->questions->contains($question)) {
  245.             $this->questions[] = $question;
  246.             $question->setAskedBy($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeQuestion(Question $question): self
  253.     {
  254.         if ($this->questions->removeElement($question)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($question->getAskedBy() === $this) {
  257.                 $question->setAskedBy(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @return Collection|Answer[]
  266.      */
  267.     public function getAnswers(): Collection
  268.     {
  269.         return $this->answers;
  270.     }
  272.     public function addAnswer(Answer $answer): self
  273.     {
  274.         if (!$this->answers->contains($answer)) {
  275.             $this->answers[] = $answer;
  276.             $answer->setAnsweredBy($this);
  277.         }
  279.         return $this;
  280.     }
  282.     public function removeAnswer(Answer $answer): self
  283.     {
  284.         if ($this->answers->removeElement($answer)) {
  285.             // set the owning side to null (unless already changed)
  286.             if ($answer->getAnsweredBy() === $this) {
  287.                 $answer->setAnsweredBy(null);
  288.             }
  289.         }
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection<int, Comment>
  296.      */
  297.     public function getComments(): Collection
  298.     {
  299.         return $this->comments;
  300.     }
  302.     public function addComment(Comment $comment): static
  303.     {
  304.         if (!$this->comments->contains($comment)) {
  305.             $this->comments->add($comment);
  306.             $comment->setUser($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeComment(Comment $comment): static
  313.     {
  314.         if ($this->comments->removeElement($comment)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($comment->getUser() === $this) {
  317.                 $comment->setUser(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  323. }