src/Entity/User.php line 33

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiProperty;
  6. use App\Annotations\HideFromView;
  7. use App\Trait\EntityTrait;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use App\Repository\UserRepository;
  12. use Symfony\Component\Serializer\Annotation\Ignore;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use ApiPlatform\Action\NotFoundAction;
  16. use ApiPlatform\Metadata\Get;
  17. use ApiPlatform\Metadata\GetCollection;
  18. use ApiPlatform\Metadata\ApiResource;
  19. use Symfony\Component\Serializer\Annotation\MaxDepth;
  20. use Scheb\TwoFactorBundle\Model\Email\TwoFactorInterface;
  24. /**
  25.  * User entity
  26.  */
  28. #[ApiResource(
  29.     normalizationContext: ['enable_max_depth'=>true],
  30. )]
  31. #[ORM\Entity(repositoryClass: UserRepository::class)]
  32. #[ORM\Table(name: '`user`')]
  33. class User implements UserInterface, PasswordAuthenticatedUserInterface, TwoFactorInterface
  34. {
  35.     use EntityTrait;
  37.     /**
  38.      * ID
  39.      */
  40.     #[ORM\Id]
  41.     #[ORM\GeneratedValue]
  42.     #[ORM\Column]
  43.     private ?int $id = null;
  45.     /**
  46.      * @var string $username Max length 180, unique, not nullable
  47.      */
  48.     #[ORM\Column(length: 180, unique: true)]
  49.     private ?string $username = null;
  51.     // TODO: relation with UserRoles, OneToMany
  52.     /**
  53.      * The list of the user's roles
  54.      */
  55.     #[ORM\Column]
  56.     private array $roles = [];
  58.     /**
  59.      * @var string The hashed password
  60.      */
  61.     #[Ignore]
  62.     #[ORM\Column]
  63.     private ?string $password = null;
  65.     /**
  66.      * @var string $apiToken Max length 255, unique, not nullable
  67.      */
  68.     #[ORM\Column(length: 255, unique: true)]
  69.     private ?string $apiToken = null;
  71.     /**
  72.      * @var string $email Max length 255, not nullable
  73.      */
  74.     #[ORM\Column(length: 255)]
  75.     private ?string $email = null;
  77.     /**
  78.      * @var bool $enable Not nullable
  79.      */
  80.     #[ORM\Column]
  81.     private ?bool $enable = null;
  83.     #[MaxDepth(1)]
  84.     #[ORM\ManyToMany(targetEntity: UserGroup::class, mappedBy: 'users')]
  85.     private Collection $userGroups;
  87.     #[ORM\ManyToOne(inversedBy: 'users')]
  88.     private ?Channel $channel = null;
  90.     #[MaxDepth(1)]
  91.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  92.     private ?RefillSetting $refillSetting = null;
  93.     
  94.     #[Ignore]
  95.     #[HideFromView]
  96.     #[MaxDepth(1)]
  97.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Refill::class)]
  98.     private Collection $refills;
  101.     #[ORM\Column(length: 255)]
  102.     private ?string $authCode;
  106.     public function __construct()
  107.     {
  108.         $this->userGroups = new ArrayCollection();
  109.         $this->refills = new ArrayCollection();
  110.     }
  112.     /**
  113.      * Getter for the entity's id property
  114.      * 
  115.      * @return int The id property
  116.      */
  117.     public function getId(): ?int
  118.     {
  119.         return $this->id;
  120.     }
  122.     /**
  123.      * Setter for the entity's id property
  124.      * 
  125.      * @param $id The property's new value
  126.      * @return self
  127.      */
  128.     public function setId(int $id): self
  129.     {
  130.         $this->id = $id;
  131.     
  132.         return $this;
  133.     }
  135.     /**
  136.      * Getter for the entity's username property
  137.      * 
  138.      * @return string The username property
  139.      */
  140.     public function getUsername(): ?string
  141.     {
  142.         return $this->username;
  143.     }
  145.     /**
  146.      * Setter for the entity's username property
  147.      * 
  148.      * @param $username The property's new value
  149.      * @return self
  150.      */
  151.     public function setUsername(string $username): self
  152.     {
  153.         $this->username = $username;
  154.     
  155.         return $this;
  156.     }
  158.     /**
  159.      * A visual identifier that represents this user.
  160.      *
  161.      * @see UserInterface
  162.      */
  163.     public function getUserIdentifier(): string
  164.     {
  165.         return (string) $this->username;
  166.     }
  168.     /**
  169.      * @see UserInterface
  170.      */
  171.     public function getRoles(): array
  172.     {
  173.         $roles = $this->roles;    // Roles belonging to the user
  174.    
  175.         foreach ($this->userGroups as $group)
  176.         {
  177.             foreach ($group->getRoles() as $groupRole)
  178.             {
  179.                 array_push($roles, $groupRole);
  180.             }
  181.         }
  182.         
  183.         $roles[] = 'ROLE_STDUSER';    // guarantee every user at least has ROLE_USER
  184.     
  185.         return array_unique($roles); // Instead of checking every element with in_array, I just remove duplicates at the end
  186.     }
  188.     /**
  189.      * Setter for the entity's roles property
  190.      * 
  191.      * @param $roles The property's new value
  192.      * @return self
  193.      */
  194.     public function setRoles(array $roles): self
  195.     {
  196.         $this->roles = $roles;
  197.     
  198.         return $this;
  199.     }
  201.     /**
  202.      * @see PasswordAuthenticatedUserInterface
  203.      */
  204.     public function getPassword(): string
  205.     {
  206.         return $this->password;
  207.     }
  209.     /**
  210.      * Setter for the entity's password property
  211.      * 
  212.      * @param $password The property's new value
  213.      * @return self
  214.      */
  215.     public function setPassword(string $password): self
  216.     {
  217.         $this->password = $password;
  218.     
  219.         return $this;
  220.     }
  222.     /**
  223.      * @see UserInterface
  224.      */
  225.     public function eraseCredentials()
  226.     {
  227.         // If you store any temporary, sensitive data on the user, clear it here
  228.         // $this->plainPassword = null;
  229.     }
  231.     /**
  232.      * Getter for the entity's apiToken property
  233.      * 
  234.      * @return string The apiToken property
  235.      */
  236.     public function getApiToken(): ?string
  237.     {
  238.         return $this->apiToken;
  239.     }
  241.     /**
  242.      * Setter for the entity's apiToken property
  243.      * 
  244.      * @param $apiToken The property's new value
  245.      * @return self
  246.      */
  247.     public function setApiToken(?string $apiToken): self
  248.     {
  249.         $this->apiToken = $apiToken;
  250.     
  251.         return $this;
  252.     }
  254.     /**
  255.      * @return string|null
  256.      */
  257.     public function getAuthCode(): ?string
  258.     {
  259.         return $this->authCode;
  260.     }
  262.     /**
  263.      * @param string|null $authCode
  264.      */
  265.     public function setAuthCode(?string $authCode): void
  266.     {
  267.         $this->authCode = $authCode;
  268.     }
  269.     /**
  270.      * Getter for the entity's email property
  271.      * 
  272.      * @return string The email property
  273.      */
  274.     public function getEmail(): ?string
  275.     {
  276.         return $this->email;
  277.     }
  279.     /**
  280.      * Setter for the entity's email property
  281.      * 
  282.      * @param $email The property's new value
  283.      * @return self
  284.      */
  285.     public function setEmail(string $email): self
  286.     {
  287.         $this->email = $email;
  288.     
  289.         return $this;
  290.     }
  292.     /**
  293.      * Converts the entity to a string. Used to show a string that represents the entity in form fields
  294.      * 
  295.      * @return string The username
  296.      */
  297.     public function __toString()
  298.     {
  299.         return $this->username;
  300.     }
  302.     /**
  303.      * Getter for the entity's enable property
  304.      * 
  305.      * @return string The enable property
  306.      */
  307.     public function isEnable(): ?bool
  308.     {
  309.         return $this->enable;
  310.     }
  312.     /**
  313.      * Setter for the entity's enable property
  314.      * 
  315.      * @param $enable The property's new value
  316.      * @return self
  317.      */
  318.     public function setEnable(bool $enable): self
  319.     {
  320.         $this->enable = $enable;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, UserGroup>
  327.      */
  328.     public function getUserGroups(): Collection
  329.     {
  330.         return $this->userGroups;
  331.     }
  333.     public function addUserGroup(UserGroup $userGroup): self
  334.     {
  335.         if (!$this->userGroups->contains($userGroup)) {
  336.             $this->userGroups->add($userGroup);
  337.             $userGroup->addUser($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeUserGroup(UserGroup $userGroup): self
  344.     {
  345.         if ($this->userGroups->removeElement($userGroup)) {
  346.             $userGroup->removeUser($this);
  347.         }
  349.         return $this;
  350.     }
  352.     /**
  353.      * Gets the total amount of tokens belonging to the user, not taking into consideration entity type and action
  354.      */
  355.     public function getBalance(): ?int
  356.     {
  357.         $balance = 0;
  359.         foreach($this->refills as $refill)
  360.             $balance += ($refill->getQuantity() - $refill->getUsed());
  362.         return $balance;
  363.     }
  365.     public function getChannel(): ?Channel
  366.     {
  367.         return $this->channel;
  368.     }
  370.     public function setChannel(?Channel $channel): self
  371.     {
  372.         $this->channel = $channel;
  374.         return $this;
  375.     }
  377.     public function getRefillSetting(): ?RefillSetting
  378.     {
  379.         return $this->refillSetting;
  380.     }
  382.     public function setRefillSetting(?RefillSetting $refillSetting): self
  383.     {
  384.         // unset the owning side of the relation if necessary
  385.         if ($refillSetting === null && $this->refillSetting !== null) {
  386.             $this->refillSetting->setUser(null);
  387.         }
  389.         // set the owning side of the relation if necessary
  390.         if ($refillSetting !== null && $refillSetting->getUser() !== $this) {
  391.             $refillSetting->setUser($this);
  392.         }
  394.         $this->refillSetting = $refillSetting;
  396.         return $this;
  397.     }
  399.     /**
  400.      * @return Collection<int, Refill>
  401.      */
  402.     public function getRefills(): Collection
  403.     {
  404.         return $this->refills;
  405.     }
  407.     public function addRefill(Refill $refill): self
  408.     {
  409.         if (!$this->refills->contains($refill)) {
  410.             $this->refills->add($refill);
  411.             $refill->setUser($this);
  412.         }
  414.         return $this;
  415.     }
  417.     public function removeRefill(Refill $refill): self
  418.     {
  419.         if ($this->refills->removeElement($refill)) {
  420.             // set the owning side to null (unless already changed)
  421.             if ($refill->getUser() === $this) {
  422.                 $refill->setUser(null);
  423.             }
  424.         }
  426.         return $this;
  427.     }
  429.     public function isEmailAuthEnabled(): bool
  430.     {
  431.         return true; // This can be a persisted field to switch email code authentication on/off
  432.     }
  434.     public function getEmailAuthRecipient(): string
  435.     {
  436.         return $this->email;
  437.     }
  439.     public function getEmailAuthCode(): ?string
  440.     {
  441.         /*
  442.         if (null === $this->authCode) {
  443.             throw new \LogicException('The email authentication code was not set');
  444.         }
  445.         */
  447.         return $this->authCode;
  448.     }
  450.     public function setEmailAuthCode(?string $authCode): void
  451.     {
  452.         $this->authCode = $authCode;
  453.     }
  455. }