src/Entity/User.php line 17

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\Component\Validator\Constraints as Assert;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[ORM\Table(name: '`user`')]
  16. #[UniqueEntity(fields: ['email'], message: 'Il existe déjà un compte associé à cet E-mail')]
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column]
  22.     private ?int $id = null; 
  24.     #[ORM\Column(length: 180, unique: true)]
  25.     private ?string $email = null;
  27.     #[ORM\Column]
  28.     private array $roles = [];
  30.     /**
  31.      * @var string The hashed password
  32.      */
  33.     #[ORM\Column]
  34.     private ?string $password = null;
  36.     #[ORM\Column(length: 100)]
  37.     private ?string $firstname = null;
  39.     #[ORM\Column(length: 100)]
  40.     private ?string $lastname = null;
  42.     #[ORM\Column(length: 12)]
  43.     private ?string $phone = null;
  45.     #[ORM\Column(length: 150)]
  46.     private ?string $company = null;
  48.     #[ORM\Column(length: 5)]
  49.     private ?string $zipcode = null;
  51.     #[ORM\Column(length: 150)]
  52.     private ?string $city = null;
  54.     #[ORM\Column(options: ['default' => 'CURRENT_TIMESTAMP'])]
  55.     private ?\DateTimeImmutable $created_at = null;
  57.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Answer::class)]
  58.     private Collection $answers;
  60.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Comment::class)]
  61.     private Collection $comments;
  63.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Payment::class)]
  64.     private Collection $payments;
  66.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Ticket::class)]
  67.     private Collection $tickets;
  69.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Post::class)]
  70.     private Collection $posts;
  72.     #[ORM\Column(nullable: true)]
  73.     private ?bool $is_app_acces = null;
  75.     #[ORM\Column(nullable: true)]
  76.     private ?bool $is_ticket_open = null;
  78.     #[ORM\Column(nullable: true)]
  79.     private ?bool $is_logged = null;
  81.     #[ORM\Column(nullable: true)]
  82.     private ?int $nb_tickets = null;
  84.     #[ORM\Column(nullable: true)]
  85.     private ?int $nb_answers = null;
  87.     #[ORM\Column(nullable: true)]
  88.     private ?int $nb_payments = null;
  90.     #[ORM\Column(nullable: true)]
  91.     private ?int $nb_posts = null;
  93.     #[ORM\Column(nullable: true)]
  94.     private ?int $nb_comments = null;
  96.     #[ORM\Column(options: ['default' => 'CURRENT_TIMESTAMP'])]
  97.     private ?\DateTimeImmutable $last_login_at = null;
  99.     public function __construct()
  100.     {     
  101.         $this->created_at = new \DateTimeImmutable();  
  102.         $this->answers = new ArrayCollection();
  103.         $this->comments = new ArrayCollection();
  104.         $this->payments = new ArrayCollection();
  105.         $this->tickets = new ArrayCollection();
  106.         $this->posts = new ArrayCollection();
  107.     }
  109.     public function getId(): ?int
  110.     {
  111.         return $this->id;
  112.     }
  114.     public function getEmail(): ?string
  115.     {
  116.         return $this->email;
  117.     }
  119.     public function setEmail(string $email): self
  120.     {
  121.         $this->email = $email;
  123.         return $this;
  124.     }
  126.     /**
  127.      * A visual identifier that represents this user.
  128.      *
  129.      * @see UserInterface
  130.      */
  131.     public function getUserIdentifier(): string
  132.     {
  133.         return (string) $this->email;
  134.     }
  136.     /**
  137.      * @see UserInterface
  138.      */
  139.     public function getRoles(): array
  140.     {
  141.         $roles = $this->roles;
  142.         // guarantee every user at least has ROLE_USER
  143.         $roles[] = 'ROLE_USER';
  145.         return array_unique($roles);
  146.     }
  148.     public function setRoles(array $roles): self
  149.     {
  150.         $this->roles = $roles;
  152.         return $this;
  153.     }
  155.     /**
  156.      * @see PasswordAuthenticatedUserInterface
  157.      */
  158.     public function getPassword(): string
  159.     {
  160.         return $this->password;
  161.     }
  163.     public function setPassword(string $password): self
  164.     {
  165.         $this->password = $password;
  167.         return $this;
  168.     }
  170.     /**
  171.      * @see UserInterface
  172.      */
  173.     public function eraseCredentials()
  174.     {
  175.         // If you store any temporary, sensitive data on the user, clear it here
  176.         // $this->plainPassword = null;
  177.     }
  179.     public function getFirstname(): ?string
  180.     {
  181.         return $this->firstname;
  182.     }
  184.     public function setFirstname(string $firstname): self
  185.     {
  186.         $this->firstname = $firstname;
  188.         return $this;
  189.     }
  191.     public function getLastname(): ?string
  192.     {
  193.         return $this->lastname;
  194.     }
  196.     public function setLastname(string $lastname): self
  197.     {
  198.         $this->lastname = $lastname;
  200.         return $this;
  201.     }
  202.     
  203.     public function getPhone(): ?string
  204.     {
  205.         return $this->phone;
  206.     }
  208.     public function setPhone(string $phone): self
  209.     {
  210.         $this->phone = $phone;
  212.         return $this;
  213.     }
  215.     public function getCompany(): ?string
  216.     {
  217.         return $this->company;
  218.     }
  220.     public function setCompany(string $company): self
  221.     {
  222.         $this->company = $company;
  224.         return $this;
  225.     }
  227.     public function getZipcode(): ?string
  228.     {
  229.         return $this->zipcode;
  230.     }
  232.     public function setZipcode(string $zipcode): self
  233.     {
  234.         $this->zipcode = $zipcode;
  236.         return $this;
  237.     }
  239.     public function getCity(): ?string
  240.     {
  241.         return $this->city;
  242.     }
  244.     public function setCity(string $city): self
  245.     {
  246.         $this->city = $city;
  248.         return $this;
  249.     }
  251.     public function getCreatedAt(): ?\DateTimeImmutable
  252.     {
  253.         return $this->created_at;
  254.     }
  256.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  257.     {
  258.         $this->created_at = $created_at;
  260.         return $this;
  261.     }
  263.     /**
  264.      * @return Collection<int, Answer>
  265.      */
  266.     public function getAnswers(): Collection
  267.     {
  268.         return $this->answers;
  269.     }
  271.     public function addAnswer(Answer $answer): self
  272.     {
  273.         if (!$this->answers->contains($answer)) {
  274.             $this->answers->add($answer);
  275.             $answer->setUser($this);
  276.         }
  278.         return $this;
  279.     }
  281.     public function removeAnswer(Answer $answer): self
  282.     {
  283.         if ($this->answers->removeElement($answer)) {
  284.             // set the owning side to null (unless already changed)
  285.             if ($answer->getUser() === $this) {
  286.                 $answer->setUser(null);
  287.             }
  288.         }
  290.         return $this;
  291.     }
  293.     /**
  294.      * @return Collection<int, Comment>
  295.      */
  296.     public function getComments(): Collection
  297.     {
  298.         return $this->comments;
  299.     }
  301.     public function addComment(Comment $comment): self
  302.     {
  303.         if (!$this->comments->contains($comment)) {
  304.             $this->comments->add($comment);
  305.             $comment->setUser($this);
  306.         }
  308.         return $this;
  309.     }
  311.     public function removeComment(Comment $comment): self
  312.     {
  313.         if ($this->comments->removeElement($comment)) {
  314.             // set the owning side to null (unless already changed)
  315.             if ($comment->getUser() === $this) {
  316.                 $comment->setUser(null);
  317.             }
  318.         }
  320.         return $this;
  321.     }
  323.     /**
  324.      * @return Collection<int, Payment>
  325.      */
  326.     public function getPayments(): Collection
  327.     {
  328.         return $this->payments;
  329.     }
  331.     public function addPayment(Payment $payment): self
  332.     {
  333.         if (!$this->payments->contains($payment)) {
  334.             $this->payments->add($payment);
  335.             $payment->setUser($this);
  336.         }
  338.         return $this;
  339.     }
  341.     public function removePayment(Payment $payment): self
  342.     {
  343.         if ($this->payments->removeElement($payment)) {
  344.             // set the owning side to null (unless already changed)
  345.             if ($payment->getUser() === $this) {
  346.                 $payment->setUser(null);
  347.             }
  348.         }
  350.         return $this;
  351.     }
  353.     /**
  354.      * @return Collection<int, Ticket>
  355.      */
  356.     public function getTickets(): Collection
  357.     {
  358.         return $this->tickets;
  359.     }
  361.     public function addTicket(Ticket $ticket): self
  362.     {
  363.         if (!$this->tickets->contains($ticket)) {
  364.             $this->tickets->add($ticket);
  365.             $ticket->setUser($this);
  366.         }
  368.         return $this;
  369.     }
  371.     public function removeTicket(Ticket $ticket): self
  372.     {
  373.         if ($this->tickets->removeElement($ticket)) {
  374.             // set the owning side to null (unless already changed)
  375.             if ($ticket->getUser() === $this) {
  376.                 $ticket->setUser(null);
  377.             }
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.      * @return Collection<int, Post>
  385.      */
  386.     public function getPosts(): Collection
  387.     {
  388.         return $this->posts;
  389.     }
  391.     public function addPost(Post $post): self
  392.     {
  393.         if (!$this->posts->contains($post)) {
  394.             $this->posts->add($post);
  395.             $post->setUser($this);
  396.         }
  398.         return $this;
  399.     }
  401.     public function removePost(Post $post): self
  402.     {
  403.         if ($this->posts->removeElement($post)) {
  404.             // set the owning side to null (unless already changed)
  405.             if ($post->getUser() === $this) {
  406.                 $post->setUser(null);
  407.             }
  408.         }
  410.         return $this;
  411.     }
  413.     public function isIsAppAcces(): ?bool
  414.     {
  415.         return $this->is_app_acces;
  416.     }
  418.     public function setIsAppAcces(?bool $is_app_acces): self
  419.     {
  420.         $this->is_app_acces = $is_app_acces;
  422.         return $this;
  423.     }
  425.     public function isIsTicketOpen(): ?bool
  426.     {
  427.         return $this->is_ticket_open;
  428.     }
  430.     public function setIsTicketOpen(?bool $is_ticket_open): self
  431.     {
  432.         $this->is_ticket_open = $is_ticket_open;
  434.         return $this;
  435.     }
  437.     public function isIsLogged(): ?bool
  438.     {
  439.         return $this->is_logged;
  440.     }
  442.     public function setIsLogged(?bool $is_logged): self
  443.     {
  444.         $this->is_logged = $is_logged;
  446.         return $this;
  447.     }
  449.     public function getLastLoginAt(): ?\DateTimeImmutable
  450.     {
  451.         return $this->last_login_at;
  452.     }
  454.     public function setLastLoginAt(\DateTimeImmutable $last_login_at): self
  455.     {
  456.         $this->last_login_at = $last_login_at;
  458.         return $this;
  459.     }
  460.     
  461.     public function getNbTickets(): ?int
  462.     {
  463.         return $this->nb_tickets;
  464.     }
  466.     public function setNbTickets(?int $nb_tickets): self
  467.     {
  468.         $this->nb_tickets = $nb_tickets;
  470.         return $this;
  471.     }
  473.     public function getNbAnswers(): ?int
  474.     {
  475.         return $this->nb_answers;
  476.     }
  478.     public function setNbAnswers(?int $nb_answers): self
  479.     {
  480.         $this->nb_answers = $nb_answers;
  482.         return $this;
  483.     }
  485.     public function getNbPayments(): ?int
  486.     {
  487.         return $this->nb_payments;
  488.     }
  490.     public function setNbPayments(?int $nb_payments): self
  491.     {
  492.         $this->nb_payments = $nb_payments;
  494.         return $this;
  495.     }
  497.     public function getNbComments(): ?int
  498.     {
  499.         return $this->nb_comments;
  500.     }
  502.     public function setNbComments(?int $nb_comments): self
  503.     {
  504.         $this->nb_comments = $nb_comments;
  506.         return $this;
  507.     }
  509.     public function getNbPosts(): ?int
  510.     {
  511.         return $this->nb_posts;
  512.     }
  514.     public function setNbPosts(?int $nb_posts): self
  515.     {
  516.         $this->nb_posts = $nb_posts;
  518.         return $this;
  519.     }
  521. }