src/Entity/User.php line 45

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\Get;
  7. use ApiPlatform\Metadata\GetCollection;
  8. use App\Controller\CustomController;
  9. use App\EntityListener\UserListener;
  10. use DateTimeImmutable;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\DBAL\Types\Types;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use App\Repository\UserRepository;
  16. use Serializable;
  17. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  18. use Symfony\Component\HttpFoundation\File\File;
  19. use Symfony\Component\Security\Core\User\UserInterface;
  20. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  21. use Symfony\Component\Serializer\Annotation\Groups;
  22. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  24. #[ORM\Entity(repositoryClass: UserRepository::class)]
  25. #[ORM\Table(name: '`user`')]
  26. #[ORM\HasLifecycleCallbacks]
  27. #[Vich\Uploadable]
  28. #[UniqueEntity(fields: ['email'], message: 'Il existe déjà un compte avec cette adresse mail.')]
  29. #[ORM\EntityListeners([UserListener::class])]
  30. #[ApiResource(
  31.     operations: [
  32.         new Get(
  33.             normalizationContext: [
  34.                 'groups' => 'user:item'
  35.             ]
  36.         ),
  37.         new GetCollection(
  38.             normalizationContext: [
  39.                 'groups' => 'user:list'
  40.             ]
  41.         ),
  42.     ],
  43.     paginationEnabled: false,
  44. )]
  45. class User implements UserInterface, PasswordAuthenticatedUserInterface, Serializable
  46. {
  47.     #[ORM\Id]
  48.     #[ORM\GeneratedValue]
  49.     #[ORM\Column]
  50.     #[Groups(['user:list', 'user:item', 'assignment:item', 'assignment:list'])]
  51.     private ?int $id = null;
  53.     #[ORM\Column(length: 180, nullable: true)]
  54.     #[Groups(['user:list', 'user:item'])]
  55.     private ?string $username = null;
  57.     #[ORM\Column(length: 255, nullable: true)]
  58.     #[Groups(['user:list', 'user:item', 'assignment:item'])]
  59.     private ?string $firstName = null;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     #[Groups(['user:list', 'user:item', 'assignment:item'])]
  63.     private ?string $lastName = null;
  65.     #[ORM\ManyToOne(inversedBy: 'users')]
  66.     #[ORM\JoinColumn(nullable: true)]
  67.     #[Groups(['user:list', 'user:item'])]
  68.     private ?Role $role = null;
  70.     #[ORM\Column]
  71.     #[Groups(['user:list', 'user:item'])]
  72.     private ?string $password = null;
  74.     #[ORM\Column(length: 255, unique: true)]
  75.     #[Groups(['user:list', 'user:item'])]
  76.     private ?string $email = null;
  78.     #[ORM\Column(length: 255, nullable: true)]
  79.     #[Groups(['user:list', 'user:item'])]
  80.     private ?string $phone = null;
  82.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true, options: [
  83.         "default" => null
  84.     ])]
  85.     #[Groups(['user:list', 'user:item'])]
  86.     private ?string $imageName = null;
  88.     #[Vich\UploadableField(mapping: 'user_img', fileNameProperty: 'imageName', size: 'imageSize')]
  89.     private ?File $imageFile = null;
  91.     #[ORM\Column(type: 'integer', nullable: true)]
  92.     private ?int $imageSize = null;
  94.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  95.     private bool $isVerified = false;
  97.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  98.         "default" => "CURRENT_TIMESTAMP"
  99.     ])]
  100.     private ?DateTimeImmutable $createdAt = null;
  102.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  103.         "default" => "CURRENT_TIMESTAMP"
  104.     ])]
  105.     private ?DateTimeImmutable $updatedAt = null;
  107.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  108.     #[Groups(['user:list', 'user:item'])]
  109.     private ?bool $isActivated = false;
  111.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  112.     #[Groups(['user:list', 'user:item'])]
  113.     private ?bool $isDeleted = false;
  115.     #[ORM\OneToMany(mappedBy: 'sender', targetEntity: Message::class)]
  116.     private Collection $senders;
  118.     #[ORM\OneToMany(mappedBy: 'receiver', targetEntity: Message::class)]
  119.     private Collection $receivers;
  121.     #[ORM\OneToMany(mappedBy: 'copy', targetEntity: Message::class)]
  122.     private Collection $copies;
  124.     #[ORM\OneToMany(mappedBy: 'replyTo', targetEntity: Message::class)]
  125.     private Collection $repliesTo;
  127.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Session::class)]
  128.     private Collection $sessions;
  130.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: MailNotification::class)]
  131.     private Collection $mailNotifcations;
  133.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Assignment::class)]
  134.     private Collection $assignments;
  136.     public function __construct()
  137.     {
  138.         $this->senders = new ArrayCollection();
  139.         $this->receivers = new ArrayCollection();
  140.         $this->copies = new ArrayCollection();
  141.         $this->repliesTo = new ArrayCollection();
  142.         $this->sessions = new ArrayCollection();
  143.         $this->mailNotifcations = new ArrayCollection();
  144.         $this->assignments = new ArrayCollection();
  145.     }
  147.     public function getId(): ?int
  148.     {
  149.         return $this->id;
  150.     }
  152.     /**
  153.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  154.      */
  155.     public function getUsername(): ?string
  156.     {
  157.         return (string)$this->username;
  158.     }
  160.     public function setUsername(?string $username): self
  161.     {
  162.         $this->username = $username;
  163.         return $this;
  164.     }
  166.     /**
  167.      * A visual identifier that represents this user.
  168.      *
  169.      * @see UserInterface
  170.      */
  171.     public function getUserIdentifier(): string
  172.     {
  173.         return (string)$this->email;
  174.     }
  176.     /**
  177.      * @see PasswordAuthenticatedUserInterface
  178.      */
  179.     public function getPassword(): string
  180.     {
  181.         if ($this->password != null)
  182.             return $this->password;
  183.         return "";
  184.     }
  186.     /**
  187.      * @param string|null $password
  188.      * @return $this
  189.      */
  190.     public function setPassword(?string $password): self
  191.     {
  192.         $this->password = $password;
  193.         return $this;
  194.     }
  196.     /**
  197.      * Returning a salt is only needed, if you are not using a modern
  198.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  199.      *
  200.      * @see UserInterface
  201.      */
  202.     public function getSalt(): ?string
  203.     {
  204.         return null;
  205.     }
  207.     /**
  208.      * @see UserInterface
  209.      */
  210.     public function eraseCredentials()
  211.     {
  212.         // If you store any temporary, sensitive data on the user, clear it here
  213.         //$this->plainPassword = null;
  214.     }
  216.     public function getFirstName(): ?string
  217.     {
  218.         return $this->firstName;
  219.     }
  221.     public function setFirstName(?string $firstName): self
  222.     {
  223.         $this->firstName = $firstName;
  224.         return $this;
  225.     }
  227.     public function getLastName(): ?string
  228.     {
  229.         return $this->lastName;
  230.     }
  232.     public function setLastName(?string $lastName): self
  233.     {
  234.         $this->lastName = $lastName;
  235.         return $this;
  236.     }
  238.     public function getEmail(): ?string
  239.     {
  240.         return $this->email;
  241.     }
  243.     public function setEmail(?string $email): self
  244.     {
  245.         $this->email = $email;
  246.         return $this;
  247.     }
  249.     public function getPhone(): ?string
  250.     {
  251.         return $this->phone;
  252.     }
  254.     public function setPhone(?string $phone): self
  255.     {
  256.         $this->phone = $phone;
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return string|null
  262.      */
  263.     public function getImageName(): ?string
  264.     {
  265.         return $this->imageName;
  266.     }
  268.     /**
  269.      * @param string|null $imageName
  270.      */
  271.     public function setImageName(?string $imageName): void
  272.     {
  273.         $this->imageName = $imageName;
  274.     }
  276.     /**
  277.      * @param File|null $imageFile
  278.      */
  279.     public function setImageFile(?File $imageFile = null): void
  280.     {
  281.         $this->imageFile = $imageFile;
  282.         if (null !== $imageFile) {
  283.             $this->updatedAt = new DateTimeImmutable;
  284.         }
  285.     }
  287.     public function getImageFile(): ?File
  288.     {
  289.         return $this->imageFile;
  290.     }
  292.     public function setImageSize(?int $imageSize): void
  293.     {
  294.         $this->imageSize = $imageSize;
  295.     }
  297.     public function getImageSize(): ?int
  298.     {
  299.         return $this->imageSize;
  300.     }
  302.     public function isVerified(): bool
  303.     {
  304.         return $this->isVerified;
  305.     }
  307.     public function setIsVerified(?bool $isVerified): self
  308.     {
  309.         $this->isVerified = $isVerified;
  311.         return $this;
  312.     }
  314.     public function getCreatedAt(): ?\DateTimeImmutable
  315.     {
  316.         return $this->createdAt;
  317.     }
  319.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  320.     {
  321.         $this->createdAt = $createdAt;
  322.         return $this;
  323.     }
  325.     public function getUpdatedAt(): ?\DateTimeImmutable
  326.     {
  327.         return $this->updatedAt;
  328.     }
  330.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  331.     {
  332.         $this->updatedAt = $updatedAt;
  333.         return $this;
  334.     }
  336.     public function isIsActivated(): ?bool
  337.     {
  338.         return $this->isActivated;
  339.     }
  341.     public function setIsActivated(bool $isActivated): self
  342.     {
  343.         $this->isActivated = $isActivated;
  344.         return $this;
  345.     }
  347.     public function isIsDeleted(): ?bool
  348.     {
  349.         return $this->isDeleted;
  350.     }
  352.     public function setIsDeleted(bool $isDeleted): self
  353.     {
  354.         $this->isDeleted = $isDeleted;
  355.         return $this;
  356.     }
  358.     public function getRole(): ?Role
  359.     {
  360.         return $this->role;
  361.     }
  363.     public function setRole(?Role $role): self
  364.     {
  365.         $this->role = $role;
  367.         return $this;
  368.     }
  370.     public function getRoles(): array
  371.     {
  372.         $roles = [];
  373.         $roles[] = 'ROLE_USER';
  374.         if ($this->getRole() != null)
  375.             $roles[] = $this->getRole()->getAlias();
  376.         return array_unique($roles);
  377.     }
  379.     /** @see \Serializable::serialize() */
  380.     public function serialize(): ?string
  381.     {
  382.         return serialize(array(
  383.             $this->id,
  384.             $this->username,
  385.             $this->firstName,
  386.             $this->lastName,
  387.             $this->password,
  388.             $this->email,
  389.             $this->phone,
  390.             $this->isVerified,
  391.             $this->isActivated,
  392.         ));
  393.     }
  395.     /** @param $serialized
  396.      * @see \Serializable::unserialize()
  397.      */
  398.     public function unserialize($serialized)
  399.     {
  400.         list (
  401.             $this->id,
  402.             $this->username,
  403.             $this->firstName,
  404.             $this->lastName,
  405.             $this->password,
  406.             $this->email,
  407.             $this->phone,
  408.             $this->isVerified,
  409.             $this->isActivated,
  410.             ) = unserialize($serialized, array('allowed_classes' => false));
  411.     }
  413.     /**
  414.      * @return Collection<int, Message>
  415.      */
  416.     public function getSenders(): Collection
  417.     {
  418.         return $this->senders;
  419.     }
  421.     public function addSender(Message $sender): self
  422.     {
  423.         if (!$this->senders->contains($sender)) {
  424.             $this->senders->add($sender);
  425.             $sender->setSender($this);
  426.         }
  427.         return $this;
  428.     }
  430.     public function removeSender(Message $sender): self
  431.     {
  432.         if ($this->senders->removeElement($sender)) {
  433.             // set the owning side to null (unless already changed)
  434.             if ($sender->getSender() === $this) {
  435.                 $sender->setSender(null);
  436.             }
  437.         }
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection<int, Message>
  443.      */
  444.     public function getReceivers(): Collection
  445.     {
  446.         return $this->receivers;
  447.     }
  449.     public function addReceiver(Message $receiver): self
  450.     {
  451.         if (!$this->receivers->contains($receiver)) {
  452.             $this->receivers->add($receiver);
  453.             $receiver->setReceiver($this);
  454.         }
  455.         return $this;
  456.     }
  458.     public function removeReceiver(Message $receiver): self
  459.     {
  460.         if ($this->receivers->removeElement($receiver)) {
  461.             // set the owning side to null (unless already changed)
  462.             if ($receiver->getReceiver() === $this) {
  463.                 $receiver->setReceiver(null);
  464.             }
  465.         }
  466.         return $this;
  467.     }
  469.     /**
  470.      * @return Collection<int, Message>
  471.      */
  472.     public function getCopies(): Collection
  473.     {
  474.         return $this->copies;
  475.     }
  477.     public function addCopy(Message $copy): self
  478.     {
  479.         if (!$this->copies->contains($copy)) {
  480.             $this->copies->add($copy);
  481.             $copy->setCopy($this);
  482.         }
  483.         return $this;
  484.     }
  486.     public function removeCopy(Message $copy): self
  487.     {
  488.         if ($this->copies->removeElement($copy)) {
  489.             // set the owning side to null (unless already changed)
  490.             if ($copy->getCopy() === $this) {
  491.                 $copy->setCopy(null);
  492.             }
  493.         }
  494.         return $this;
  495.     }
  497.     /**
  498.      * @return Collection<int, Message>
  499.      */
  500.     public function getRepliesTo(): Collection
  501.     {
  502.         return $this->repliesTo;
  503.     }
  505.     public function addRepliesTo(Message $repliesTo): self
  506.     {
  507.         if (!$this->repliesTo->contains($repliesTo)) {
  508.             $this->repliesTo->add($repliesTo);
  509.             $repliesTo->setReplyTo($this);
  510.         }
  511.         return $this;
  512.     }
  514.     public function removeRepliesTo(Message $repliesTo): self
  515.     {
  516.         if ($this->repliesTo->removeElement($repliesTo)) {
  517.             // set the owning side to null (unless already changed)
  518.             if ($repliesTo->getReplyTo() === $this) {
  519.                 $repliesTo->setReplyTo(null);
  520.             }
  521.         }
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, Session>
  527.      */
  528.     public function getSessions(): Collection
  529.     {
  530.         return $this->sessions;
  531.     }
  533.     public function addSession(Session $session): self
  534.     {
  535.         if (!$this->sessions->contains($session)) {
  536.             $this->sessions->add($session);
  537.             $session->setUser($this);
  538.         }
  539.         return $this;
  540.     }
  542.     public function removeSession(Session $session): self
  543.     {
  544.         if ($this->sessions->removeElement($session)) {
  545.             // set the owning side to null (unless already changed)
  546.             if ($session->getUser() === $this) {
  547.                 $session->setUser(null);
  548.             }
  549.         }
  550.         return $this;
  551.     }
  553.     /**
  554.      * @return Collection<int, MailNotification>
  555.      */
  556.     public function getMailNotifcations(): Collection
  557.     {
  558.         return $this->mailNotifcations;
  559.     }
  561.     public function addMailNotifcation(MailNotification $mailNotifcation): self
  562.     {
  563.         if (!$this->mailNotifcations->contains($mailNotifcation)) {
  564.             $this->mailNotifcations->add($mailNotifcation);
  565.             $mailNotifcation->setUser($this);
  566.         }
  568.         return $this;
  569.     }
  571.     public function removeMailNotifcation(MailNotification $mailNotifcation): self
  572.     {
  573.         if ($this->mailNotifcations->removeElement($mailNotifcation)) {
  574.             // set the owning side to null (unless already changed)
  575.             if ($mailNotifcation->getUser() === $this) {
  576.                 $mailNotifcation->setUser(null);
  577.             }
  578.         }
  580.         return $this;
  581.     }
  583.     /**
  584.      * @return Collection<int, Assignment>
  585.      */
  586.     public function getAssignments(): Collection
  587.     {
  588.         return $this->assignments;
  589.     }
  591.     public function addAssignment(Assignment $assignment): self
  592.     {
  593.         if (!$this->assignments->contains($assignment)) {
  594.             $this->assignments->add($assignment);
  595.             $assignment->setUser($this);
  596.         }
  598.         return $this;
  599.     }
  601.     public function removeAssignment(Assignment $assignment): self
  602.     {
  603.         if ($this->assignments->removeElement($assignment)) {
  604.             // set the owning side to null (unless already changed)
  605.             if ($assignment->getUser() === $this) {
  606.                 $assignment->setUser(null);
  607.             }
  608.         }
  610.         return $this;
  611.     }
  612. }