src/Entity/User.php line 44

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\Get;
  7. use ApiPlatform\Metadata\GetCollection;
  8. use App\EntityListener\UserListener;
  9. use DateTimeImmutable;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\DBAL\Types\Types;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use App\Repository\UserRepository;
  15. use Serializable;
  16. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  17. use Symfony\Component\HttpFoundation\File\File;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  20. use Symfony\Component\Serializer\Annotation\Groups;
  21. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  23. #[ORM\Entity(repositoryClass: UserRepository::class)]
  24. #[ORM\Table(name: '`app_user`')]
  25. #[ORM\HasLifecycleCallbacks]
  26. #[Vich\Uploadable]
  27. #[UniqueEntity(fields: ['username'], message: 'Il existe déjà un compte avec cet identifiant.')]
  28. #[ORM\EntityListeners([UserListener::class])]
  29. #[ApiResource(
  30.     operations: [
  31.         new Get(
  32.             normalizationContext: [
  33.                 'groups' => 'user:item'
  34.             ]
  35.         ),
  36.         new GetCollection(
  37.             normalizationContext: [
  38.                 'groups' => 'user:list'
  39.             ]
  40.         ),
  41.     ],
  42.     paginationEnabled: false,
  43. )]
  44. class User implements UserInterface, PasswordAuthenticatedUserInterface, Serializable
  45. {
  46.     #[ORM\Id]
  47.     #[ORM\GeneratedValue]
  48.     #[ORM\Column]
  49.     #[Groups(['user:list', 'user:item', 'assignment:item', 'assignment:list'])]
  50.     private ?int $id = null;
  52.     #[ORM\Column(name: '`user_login`', length: 255, unique: true)]
  53.     #[Groups(['user:list', 'user:item'])]
  54.     private ?string $username = null;
  56.     #[ORM\Column(name: '`display_name`', length: 255, nullable: true)]
  57.     #[Groups(['user:list', 'user:item', 'assignment:item'])]
  58.     private ?string $displayName = null;
  60.     #[ORM\ManyToOne(inversedBy: 'users')]
  61.     #[ORM\JoinColumn(nullable: true)]
  62.     #[Groups(['user:list', 'user:item'])]
  63.     private ?Role $role = null;
  65.     #[ORM\Column(type: Types::BOOLEAN, nullable: true, options: [
  66.         "default" => 0
  67.     ])]
  68.     #[Groups(['user:list', 'user:item'])]
  69.     private ?bool $isClient = null;
  71.     #[ORM\ManyToOne(inversedBy: 'users')]
  72.     #[ORM\JoinColumn(nullable: true)]
  73.     #[Groups(['user:list', 'user:item'])]
  74.     private ?Client $client = null;
  76.     #[ORM\Column(name: '`user_pass`')]
  77.     #[Groups(['user:list', 'user:item'])]
  78.     private ?string $password = null;
  80.     #[ORM\Column(name: '`user_email`', length: 255)]
  81.     #[Groups(['user:list', 'user:item'])]
  82.     private ?string $email = null;
  84.     #[ORM\Column(length: 255, nullable: true)]
  85.     #[Groups(['user:list', 'user:item'])]
  86.     private ?string $phone = null;
  88.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true, options: [
  89.         "default" => null
  90.     ])]
  91.     #[Groups(['user:list', 'user:item'])]
  92.     private ?string $imageName = null;
  94.     #[Vich\UploadableField(mapping: 'user_img', fileNameProperty: 'imageName', size: 'imageSize')]
  95.     private ?File $imageFile = null;
  97.     #[ORM\Column(type: 'integer', nullable: true)]
  98.     private ?int $imageSize = null;
  100.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  101.     private bool $isVerified = false;
  103.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  104.         "default" => "CURRENT_TIMESTAMP"
  105.     ])]
  106.     private ?DateTimeImmutable $createdAt = null;
  108.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, options: [
  109.         "default" => "CURRENT_TIMESTAMP"
  110.     ])]
  111.     private ?DateTimeImmutable $updatedAt = null;
  113.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  114.     #[Groups(['user:list', 'user:item'])]
  115.     private ?bool $isActivated = false;
  117.     #[ORM\Column(type: Types::BOOLEAN, options: ["default" => "0"])]
  118.     #[Groups(['user:list', 'user:item'])]
  119.     private ?bool $isDeleted = false;
  121.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Card::class)]
  122.     private Collection $cards;
  124.     public function __construct()
  125.     {
  126.         $this->cards = new ArrayCollection();
  127.     }
  129.     public function getId(): ?int
  130.     {
  131.         return $this->id;
  132.     }
  134.     /**
  135.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  136.      */
  137.     public function getUsername(): ?string
  138.     {
  139.         return (string)$this->username;
  140.     }
  142.     public function setUsername(?string $username): self
  143.     {
  144.         $this->username = $username;
  145.         return $this;
  146.     }
  148.     /**
  149.      * A visual identifier that represents this user.
  150.      *
  151.      * @see UserInterface
  152.      */
  153.     public function getUserIdentifier(): string
  154.     {
  155.         return (string)$this->username;
  156.     }
  158.     /**
  159.      * @see PasswordAuthenticatedUserInterface
  160.      */
  161.     public function getPassword(): string
  162.     {
  163.         if ($this->password != null)
  164.             return $this->password;
  165.         return "";
  166.     }
  168.     /**
  169.      * @param string|null $password
  170.      * @return $this
  171.      */
  172.     public function setPassword(?string $password): self
  173.     {
  174.         $this->password = $password;
  175.         return $this;
  176.     }
  178.     /**
  179.      * Returning a salt is only needed, if you are not using a modern
  180.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  181.      *
  182.      * @see UserInterface
  183.      */
  184.     public function getSalt(): ?string
  185.     {
  186.         return null;
  187.     }
  189.     /**
  190.      * @see UserInterface
  191.      */
  192.     public function eraseCredentials()
  193.     {
  194.         // If you store any temporary, sensitive data on the user, clear it here
  195.         //$this->plainPassword = null;
  196.     }
  198.     public function getDisplayName(): ?string
  199.     {
  200.         return $this->displayName;
  201.     }
  203.     public function setDisplayName(?string $displayName): self
  204.     {
  205.         $this->displayName = $displayName;
  206.         return $this;
  207.     }
  209.     public function getEmail(): ?string
  210.     {
  211.         return $this->email;
  212.     }
  214.     public function setEmail(?string $email): self
  215.     {
  216.         $this->email = $email;
  217.         return $this;
  218.     }
  220.     public function getPhone(): ?string
  221.     {
  222.         return $this->phone;
  223.     }
  225.     public function setPhone(?string $phone): self
  226.     {
  227.         $this->phone = $phone;
  228.         return $this;
  229.     }
  231.     /**
  232.      * @return string|null
  233.      */
  234.     public function getImageName(): ?string
  235.     {
  236.         return $this->imageName;
  237.     }
  239.     /**
  240.      * @param string|null $imageName
  241.      */
  242.     public function setImageName(?string $imageName): void
  243.     {
  244.         $this->imageName = $imageName;
  245.     }
  247.     /**
  248.      * @param File|null $imageFile
  249.      */
  250.     public function setImageFile(?File $imageFile = null): void
  251.     {
  252.         $this->imageFile = $imageFile;
  253.         if (null !== $imageFile) {
  254.             $this->updatedAt = new DateTimeImmutable;
  255.         }
  256.     }
  258.     public function getImageFile(): ?File
  259.     {
  260.         return $this->imageFile;
  261.     }
  263.     public function setImageSize(?int $imageSize): void
  264.     {
  265.         $this->imageSize = $imageSize;
  266.     }
  268.     public function getImageSize(): ?int
  269.     {
  270.         return $this->imageSize;
  271.     }
  273.     public function isVerified(): bool
  274.     {
  275.         return $this->isVerified;
  276.     }
  278.     public function setIsVerified(?bool $isVerified): self
  279.     {
  280.         $this->isVerified = $isVerified;
  282.         return $this;
  283.     }
  285.     public function getCreatedAt(): ?DateTimeImmutable
  286.     {
  287.         return $this->createdAt;
  288.     }
  290.     public function setCreatedAt(?DateTimeImmutable $createdAt): self
  291.     {
  292.         $this->createdAt = $createdAt;
  293.         return $this;
  294.     }
  296.     public function getUpdatedAt(): ?DateTimeImmutable
  297.     {
  298.         return $this->updatedAt;
  299.     }
  301.     public function setUpdatedAt(?DateTimeImmutable $updatedAt): self
  302.     {
  303.         $this->updatedAt = $updatedAt;
  304.         return $this;
  305.     }
  307.     public function isIsActivated(): ?bool
  308.     {
  309.         return $this->isActivated;
  310.     }
  312.     public function setIsActivated(bool $isActivated): self
  313.     {
  314.         $this->isActivated = $isActivated;
  315.         return $this;
  316.     }
  318.     public function isIsDeleted(): ?bool
  319.     {
  320.         return $this->isDeleted;
  321.     }
  323.     public function setIsDeleted(bool $isDeleted): self
  324.     {
  325.         $this->isDeleted = $isDeleted;
  326.         return $this;
  327.     }
  329.     public function getRole(): ?Role
  330.     {
  331.         return $this->role;
  332.     }
  334.     public function setRole(?Role $role): self
  335.     {
  336.         $this->role = $role;
  338.         return $this;
  339.     }
  341.     public function getRoles(): array
  342.     {
  343.         $roles = [];
  344.         $roles[] = 'ROLE_USER';
  345.         if ($this->getRole() != null)
  346.             $roles[] = $this->getRole()->getAlias();
  347.         return array_unique($roles);
  348.     }
  350.     /** @see \Serializable::serialize() */
  351.     public function serialize(): ?string
  352.     {
  353.         return serialize(array(
  354.             $this->id,
  355.             $this->username,
  356.             $this->displayName,
  357.             $this->password,
  358.             $this->email,
  359.             $this->phone,
  360.             $this->isVerified,
  361.             $this->isActivated,
  362.         ));
  363.     }
  365.     /** @param $serialized
  366.      * @see \Serializable::unserialize()
  367.      */
  368.     public function unserialize($serialized)
  369.     {
  370.         list (
  371.             $this->id,
  372.             $this->username,
  373.             $this->displayName,
  374.             $this->password,
  375.             $this->email,
  376.             $this->phone,
  377.             $this->isVerified,
  378.             $this->isActivated,
  379.             ) = unserialize($serialized, array('allowed_classes' => false));
  380.     }
  382.     public function getClient(): ?Client
  383.     {
  384.         return $this->client;
  385.     }
  387.     public function setClient(?Client $client): self
  388.     {
  389.         $this->client = $client;
  391.         return $this;
  392.     }
  394.     /**
  395.      * @return Collection<int, Card>
  396.      */
  397.     public function getCards(): Collection
  398.     {
  399.         return $this->cards;
  400.     }
  402.     public function addCard(Card $card): self
  403.     {
  404.         if (!$this->cards->contains($card)) {
  405.             $this->cards->add($card);
  406.             $card->setUser($this);
  407.         }
  409.         return $this;
  410.     }
  412.     public function removeCard(Card $card): self
  413.     {
  414.         if ($this->cards->removeElement($card)) {
  415.             // set the owning side to null (unless already changed)
  416.             if ($card->getUser() === $this) {
  417.                 $card->setUser(null);
  418.             }
  419.         }
  421.         return $this;
  422.     }
  424.     public function isIsClient(): ?bool
  425.     {
  426.         return $this->isClient;
  427.     }
  429.     public function setIsClient(?bool $isClient): self
  430.     {
  431.         $this->isClient = $isClient;
  433.         return $this;
  434.     }
  435. }