src/Entity/User.php line 26

  1. <?php
  3. namespace App\Entity;
  5. use App\EntityListener\UserListener;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use App\Repository\UserRepository;
  12. use Serializable;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\HttpFoundation\File\File;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  17. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  19. #[ORM\Entity(repositoryClass: UserRepository::class)]
  20. #[ORM\Table(name: '`user`')]
  21. #[ORM\HasLifecycleCallbacks]
  22. #[Vich\Uploadable]
  23. #[UniqueEntity(fields: ['username'], message: 'Il existe déjà un compte avec ce nom d\'utilisateur')]
  24. #[ORM\EntityListeners([UserListener::class])]
  26. class User implements UserInterface, PasswordAuthenticatedUserInterface, Serializable
  27. {
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     private ?int $id = null;
  33.     #[ORM\Column(length: 180, unique: true)]
  34.     private ?string $username = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     private ?string $firstName = null;
  39.     #[ORM\Column(length: 255, nullable: true)]
  40.     private ?string $lastName = null;
  42.     #[ORM\ManyToOne(inversedBy: 'users')]
  43.     #[ORM\JoinColumn(nullable: true)]
  44.     private ?Role $role = null;
  46.     #[ORM\Column]
  47.     private ?string $password = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $email = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $phone = null;
  55.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true, options: [
  56.         "default" => null
  57.     ])]
  58.     private ?string $imageName = null;
  60.     #[Vich\UploadableField(mapping: 'user_img', fileNameProperty: 'imageName', size: 'imageSize')]
  61.     private ?File $imageFile = null;
  63.     #[ORM\Column(type: 'integer', nullable: true)]
  64.     private ?int $imageSize = null;
  66.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  67.     private bool $isVerified = false;
  69.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  70.         "default" => "CURRENT_TIMESTAMP"
  71.     ])]
  72.     private ?DateTimeImmutable $createdAt = null;
  74.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  75.         "default" => "CURRENT_TIMESTAMP"
  76.     ])]
  77.     private ?DateTimeImmutable $updatedAt = null;
  79.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  80.     private ?bool $isActivated = false;
  82.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  83.     private ?bool $isDeleted = false;
  85.     #[ORM\ManyToOne(inversedBy: 'users')]
  86.     private ?GasStation $gasStation = null;
  88.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Order::class)]
  89.     private Collection $orders;
  91.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: Message::class)]
  92.     private Collection $senders;
  94.     #[ORM\OneToMany(mappedBy: 'receiver', targetEntity: Message::class)]
  95.     private Collection $receivers;
  97.     #[ORM\OneToMany(mappedBy: 'copy', targetEntity: Message::class)]
  98.     private Collection $copies;
  100.     #[ORM\OneToMany(mappedBy: 'replyTo', targetEntity: Message::class)]
  101.     private Collection $repliesTo;
  103.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Session::class)]
  104.     private Collection $sessions;
  106.     public function __construct()
  107.     {
  108.         $this->orders = new ArrayCollection();
  109.         $this->senders = new ArrayCollection();
  110.         $this->receivers = new ArrayCollection();
  111.         $this->copies = new ArrayCollection();
  112.         $this->repliesTo = new ArrayCollection();
  113.         $this->sessions = new ArrayCollection();
  114.     }
  116.     public function getId(): ?int
  117.     {
  118.         return $this->id;
  119.     }
  121.     /**
  122.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  123.      */
  124.     public function getUsername(): ?string
  125.     {
  126.         return (string)$this->username;
  127.     }
  129.     public function setUsername(?string $username): self
  130.     {
  131.         $this->username = $username;
  132.         return $this;
  133.     }
  135.     /**
  136.      * A visual identifier that represents this user.
  137.      *
  138.      * @see UserInterface
  139.      */
  140.     public function getUserIdentifier(): string
  141.     {
  142.         return (string)$this->username;
  143.     }
  145.     /**
  146.      * @see PasswordAuthenticatedUserInterface
  147.      */
  148.     public function getPassword(): string
  149.     {
  150.         if($this->password != null)
  151.             return $this->password;
  152.         return "";
  153.     }
  155.     /**
  156.      * @param string|null $password
  157.      * @return $this
  158.      */
  159.     public function setPassword(?string $password): self
  160.     {
  161.         $this->password = $password;
  162.         return $this;
  163.     }
  165.     /**
  166.      * Returning a salt is only needed, if you are not using a modern
  167.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  168.      *
  169.      * @see UserInterface
  170.      */
  171.     public function getSalt(): ?string
  172.     {
  173.         return null;
  174.     }
  176.     /**
  177.      * @see UserInterface
  178.      */
  179.     public function eraseCredentials()
  180.     {
  181.         // If you store any temporary, sensitive data on the user, clear it here
  182.         //$this->plainPassword = null;
  183.     }
  185.     public function getFirstName(): ?string
  186.     {
  187.         return $this->firstName;
  188.     }
  190.     public function setFirstName(?string $firstName): self
  191.     {
  192.         $this->firstName = $firstName;
  193.         return $this;
  194.     }
  196.     public function getLastName(): ?string
  197.     {
  198.         return $this->lastName;
  199.     }
  201.     public function setLastName(?string $lastName): self
  202.     {
  203.         $this->lastName = $lastName;
  204.         return $this;
  205.     }
  207.     public function getEmail(): ?string
  208.     {
  209.         return $this->email;
  210.     }
  212.     public function setEmail(?string $email): self
  213.     {
  214.         $this->email = $email;
  215.         return $this;
  216.     }
  218.     public function getPhone(): ?string
  219.     {
  220.         return $this->phone;
  221.     }
  223.     public function setPhone(?string $phone): self
  224.     {
  225.         $this->phone = $phone;
  226.         return $this;
  227.     }
  229.     /**
  230.      * @return string|null
  231.      */
  232.     public function getImageName(): ?string
  233.     {
  234.         return $this->imageName;
  235.     }
  237.     /**
  238.      * @param string|null $imageName
  239.      */
  240.     public function setImageName(?string $imageName): void
  241.     {
  242.         $this->imageName = $imageName;
  243.     }
  245.     /**
  246.      * @param File|null $imageFile
  247.      */
  248.     public function setImageFile(?File $imageFile = null): void
  249.     {
  250.         $this->imageFile = $imageFile;
  251.         if (null !== $imageFile) {
  252.             $this->updatedAt = new DateTimeImmutable;
  253.         }
  254.     }
  256.     public function getImageFile(): ?File
  257.     {
  258.         return $this->imageFile;
  259.     }
  261.     public function setImageSize(?int $imageSize): void
  262.     {
  263.         $this->imageSize = $imageSize;
  264.     }
  266.     public function getImageSize(): ?int
  267.     {
  268.         return $this->imageSize;
  269.     }
  271.     public function isVerified(): bool
  272.     {
  273.         return $this->isVerified;
  274.     }
  276.     public function setIsVerified(?bool $isVerified): self
  277.     {
  278.         $this->isVerified = $isVerified;
  280.         return $this;
  281.     }
  283.     public function getCreatedAt(): ?\DateTimeImmutable
  284.     {
  285.         return $this->createdAt;
  286.     }
  288.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  289.     {
  290.         $this->createdAt = $createdAt;
  291.         return $this;
  292.     }
  294.     public function getUpdatedAt(): ?\DateTimeImmutable
  295.     {
  296.         return $this->updatedAt;
  297.     }
  299.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  300.     {
  301.         $this->updatedAt = $updatedAt;
  302.         return $this;
  303.     }
  305.     public function isIsActivated(): ?bool
  306.     {
  307.         return $this->isActivated;
  308.     }
  310.     public function setIsActivated(bool $isActivated): self
  311.     {
  312.         $this->isActivated = $isActivated;
  313.         return $this;
  314.     }
  316.     public function isIsDeleted(): ?bool
  317.     {
  318.         return $this->isDeleted;
  319.     }
  321.     public function setIsDeleted(bool $isDeleted): self
  322.     {
  323.         $this->isDeleted = $isDeleted;
  324.         return $this;
  325.     }
  327.     public function getRole(): ?Role
  328.     {
  329.         return $this->role;
  330.     }
  332.     public function setRole(?Role $role): self
  333.     {
  334.         $this->role = $role;
  336.         return $this;
  337.     }
  339.     public function getRoles(): array
  340.     {
  341.         return [];
  342.     }
  344.     /** @see \Serializable::serialize() */
  345.     public function serialize(): ?string
  346.     {
  347.         return serialize(array(
  348.             $this->id,
  349.             $this->username,
  350.             $this->firstName,
  351.             $this->lastName,
  352.             $this->password,
  353.             $this->email,
  354.             $this->phone,
  355.             $this->isVerified,
  356.             $this->isActivated,
  357.             $this->gasStation,
  358.         ));
  359.     }
  361.     /** @param $serialized
  362.      * @see \Serializable::unserialize()
  363.      */
  364.     public function unserialize($serialized)
  365.     {
  366.         list (
  367.             $this->id,
  368.             $this->username,
  369.             $this->firstName,
  370.             $this->lastName,
  371.             $this->password,
  372.             $this->email,
  373.             $this->phone,
  374.             $this->isVerified,
  375.             $this->isActivated,
  376.             $this->gasStation,
  377.             ) = unserialize($serialized, array('allowed_classes' => false));
  378.     }
  380.     public function getGasStation(): ?GasStation
  381.     {
  382.         return $this->gasStation;
  383.     }
  385.     public function setGasStation(?GasStation $gasStation): self
  386.     {
  387.         $this->gasStation = $gasStation;
  389.         return $this;
  390.     }
  392.     /**
  393.      * @return Collection<int, Order>
  394.      */
  395.     public function getOrders(): Collection
  396.     {
  397.         return $this->orders;
  398.     }
  400.     public function addOrder(Order $order): self
  401.     {
  402.         if (!$this->orders->contains($order)) {
  403.             $this->orders->add($order);
  404.             $order->setUser($this);
  405.         }
  406.         return $this;
  407.     }
  409.     public function removeOrder(Order $order): self
  410.     {
  411.         if ($this->orders->removeElement($order)) {
  412.             // set the owning side to null (unless already changed)
  413.             if ($order->getUser() === $this) {
  414.                 $order->setUser(null);
  415.             }
  416.         }
  417.         return $this;
  418.     }
  420.     /**
  421.      * @return Collection<int, Message>
  422.      */
  423.     public function getSenders(): Collection
  424.     {
  425.         return $this->senders;
  426.     }
  428.     public function addSender(Message $sender): self
  429.     {
  430.         if (!$this->senders->contains($sender)) {
  431.             $this->senders->add($sender);
  432.             $sender->setSender($this);
  433.         }
  435.         return $this;
  436.     }
  438.     public function removeSender(Message $sender): self
  439.     {
  440.         if ($this->senders->removeElement($sender)) {
  441.             // set the owning side to null (unless already changed)
  442.             if ($sender->getSender() === $this) {
  443.                 $sender->setSender(null);
  444.             }
  445.         }
  447.         return $this;
  448.     }
  450.     /**
  451.      * @return Collection<int, Message>
  452.      */
  453.     public function getReceivers(): Collection
  454.     {
  455.         return $this->receivers;
  456.     }
  458.     public function addReceiver(Message $receiver): self
  459.     {
  460.         if (!$this->receivers->contains($receiver)) {
  461.             $this->receivers->add($receiver);
  462.             $receiver->setReceiver($this);
  463.         }
  465.         return $this;
  466.     }
  468.     public function removeReceiver(Message $receiver): self
  469.     {
  470.         if ($this->receivers->removeElement($receiver)) {
  471.             // set the owning side to null (unless already changed)
  472.             if ($receiver->getReceiver() === $this) {
  473.                 $receiver->setReceiver(null);
  474.             }
  475.         }
  477.         return $this;
  478.     }
  480.     /**
  481.      * @return Collection<int, Message>
  482.      */
  483.     public function getCopies(): Collection
  484.     {
  485.         return $this->copies;
  486.     }
  488.     public function addCopy(Message $copy): self
  489.     {
  490.         if (!$this->copies->contains($copy)) {
  491.             $this->copies->add($copy);
  492.             $copy->setCopy($this);
  493.         }
  495.         return $this;
  496.     }
  498.     public function removeCopy(Message $copy): self
  499.     {
  500.         if ($this->copies->removeElement($copy)) {
  501.             // set the owning side to null (unless already changed)
  502.             if ($copy->getCopy() === $this) {
  503.                 $copy->setCopy(null);
  504.             }
  505.         }
  507.         return $this;
  508.     }
  510.     /**
  511.      * @return Collection<int, Message>
  512.      */
  513.     public function getRepliesTo(): Collection
  514.     {
  515.         return $this->repliesTo;
  516.     }
  518.     public function addRepliesTo(Message $repliesTo): self
  519.     {
  520.         if (!$this->repliesTo->contains($repliesTo)) {
  521.             $this->repliesTo->add($repliesTo);
  522.             $repliesTo->setReplyTo($this);
  523.         }
  525.         return $this;
  526.     }
  528.     public function removeRepliesTo(Message $repliesTo): self
  529.     {
  530.         if ($this->repliesTo->removeElement($repliesTo)) {
  531.             // set the owning side to null (unless already changed)
  532.             if ($repliesTo->getReplyTo() === $this) {
  533.                 $repliesTo->setReplyTo(null);
  534.             }
  535.         }
  537.         return $this;
  538.     }
  540.     /**
  541.      * @return Collection<int, Session>
  542.      */
  543.     public function getSessions(): Collection
  544.     {
  545.         return $this->sessions;
  546.     }
  548.     public function addSession(Session $session): self
  549.     {
  550.         if (!$this->sessions->contains($session)) {
  551.             $this->sessions->add($session);
  552.             $session->setUser($this);
  553.         }
  555.         return $this;
  556.     }
  558.     public function removeSession(Session $session): self
  559.     {
  560.         if ($this->sessions->removeElement($session)) {
  561.             // set the owning side to null (unless already changed)
  562.             if ($session->getUser() === $this) {
  563.                 $session->setUser(null);
  564.             }
  565.         }
  567.         return $this;
  568.     }
  569. }