src/Entity/User.php line 16

  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\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Ignore;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[UniqueEntity(fields: ['email'], message: 'Пользователь с таким E-mail адресом уже зарегистрирован')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     public const ROLE_NAMES = [
  19.                        'ROLE_ROOT' => 'Руководитель',
  20.                        'ROLE_ADMIN' => 'Администратор',
  21.                        'ROLE_USER' => 'Пользователь',
  22.                        'ROLE_GUEST' => 'Гость'
  23.                    ];
  25.     private ?string $role = '';
  26.     
  27.     #[ORM\Id]
  28.     #[ORM\GeneratedValue]
  29.     #[ORM\Column]
  30.     private ?int $id = null;
  32.     #[ORM\Column(length: 180, unique: true)]
  33.     private ?string $email = null;
  35.     #[ORM\Column]
  36.     private array $roles = [];
  38.     /**
  39.      * @var string The hashed password
  40.      */
  41.     #[ORM\Column]
  42.     private ?string $password = null;
  43.     
  44.     #[ORM\Column(nullable: true)]
  45.     private ?string $vkToken = null;
  46.     
  47.     #[ORM\Column(nullable: true)]
  48.     private ?string $vkId = null;
  50.     #[ORM\Column(type: 'boolean')]
  51.     private $isVerified = false;
  53.     #[ORM\Column(options: ['default' => 0])]
  54.     private ?float $balance = null;
  56.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: BillingHistory::class)]
  57.     #[Ignore]
  58.     private Collection $billingHistories;
  60.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: BillingTransaction::class)]
  61.     #[Ignore]
  62.     private Collection $billingTransactions;
  64.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserProject::class)]
  65.     #[Ignore]
  66.     private Collection $userProjects;
  67.     
  68.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserPlatform::class)]
  69.     #[Ignore]
  70.     private Collection $userPlatforms;
  71.     
  72.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserOrd::class)]
  73.     #[Ignore]
  74.     private Collection $userOrd;
  76.     public function __construct()
  77.     {
  78.         $this->billingHistories = new ArrayCollection();
  79.         $this->billingTransactions = new ArrayCollection();
  80.         $this->userProjects = new ArrayCollection();
  81.         $this->userPlatforms = new ArrayCollection();
  82.         $this->userOrd = new ArrayCollection();
  83.     }
  85.     public function getId(): ?int
  86.     {
  87.         return $this->id;
  88.     }
  90.     public function getEmail(): ?string
  91.     {
  92.         return $this->email;
  93.     }
  95.     public function setEmail(string $email): self
  96.     {
  97.         $this->email = $email;
  99.         return $this;
  100.     }
  102.     /**
  103.      * A visual identifier that represents this user.
  104.      *
  105.      * @see UserInterface
  106.      */
  107.     public function getUserIdentifier(): string
  108.     {
  109.         return (string) $this->email;
  110.     }
  112.     /**
  113.      * @see UserInterface
  114.      */
  115.     public function getRoles(): array
  116.     {
  117.         $roles = $this->roles;
  118.         // guarantee every user at least has ROLE_USER
  119.         $roles[] = 'ROLE_USER';
  121.         return array_unique($roles);
  122.     }
  124.     public function setRoles(array $roles): self
  125.     {
  126.         $this->roles = $roles;
  128.         return $this;
  129.     }
  130.     
  131.     public function getRolesName(): string
  132.                    {
  133.                        $rolesName = [];
  134.                        foreach ($this->getRoles() as $role) $rolesName[] = self::ROLE_NAMES[$role];
  135.                        
  136.                        return implode(', ', $rolesName);
  137.                    }
  138.     
  139.     /**
  140.      * @param string $roleName
  141.      * @return bool
  142.      */
  143.     public function hasRole(string $roleName): bool
  144.     {
  145.         if (in_array($roleName, $this->roles)) return true;
  146.         return false;
  147.     }
  149.     public function getRole(): bool
  150.     {
  151.         return $this->role;
  152.     }
  153.     
  154.     /**
  155.      * @return bool
  156.      */
  157.     public function isAdmin(): bool
  158.     {
  159.         if (in_array('ROLE_ADMIN', $this->roles)) return true;
  160.         if (in_array('ROLE_ROOT', $this->roles)) return true;
  161.         return false;
  162.     }
  164.     /**
  165.      * @see PasswordAuthenticatedUserInterface
  166.      */
  167.     public function getPassword(): string
  168.     {
  169.         return $this->password;
  170.     }
  172.     public function setPassword(string $password): self
  173.     {
  174.         $this->password = $password;
  176.         return $this;
  177.     }
  179.     /**
  180.      * @see UserInterface
  181.      */
  182.     public function eraseCredentials()
  183.     {
  184.         // If you store any temporary, sensitive data on the user, clear it here
  185.         // $this->plainPassword = null;
  186.     }
  188.     public function isVerified(): bool
  189.     {
  190.         return $this->isVerified;
  191.     }
  193.     public function setIsVerified(bool $isVerified): self
  194.     {
  195.         $this->isVerified = $isVerified;
  197.         return $this;
  198.     }
  200.     public function getBalance(): ?float
  201.     {
  202.         return $this->balance;
  203.     }
  205.     public function setBalance(float $balance): self
  206.     {
  207.         $this->balance = $balance;
  209.         return $this;
  210.     }
  212.     /**
  213.      * @return Collection<int, BillingHistory>
  214.      */
  215.     public function getBillingHistories(): Collection
  216.     {
  217.         return $this->billingHistories;
  218.     }
  220.     public function addBillingHistory(BillingHistory $billingHistory): self
  221.     {
  222.         if (!$this->billingHistories->contains($billingHistory)) {
  223.             $this->billingHistories->add($billingHistory);
  224.             $billingHistory->setUser($this);
  225.         }
  227.         return $this;
  228.     }
  230.     public function removeBillingHistory(BillingHistory $billingHistory): self
  231.     {
  232.         if ($this->billingHistories->removeElement($billingHistory)) {
  233.             // set the owning side to null (unless already changed)
  234.             if ($billingHistory->getUser() === $this) {
  235.                 $billingHistory->setUser(null);
  236.             }
  237.         }
  239.         return $this;
  240.     }
  242.     /**
  243.      * @return Collection<int, BillingTransaction>
  244.      */
  245.     public function getBillingTransactions(): Collection
  246.     {
  247.         return $this->billingTransactions;
  248.     }
  250.     public function addBillingTransaction(BillingTransaction $billingTransaction): self
  251.     {
  252.         if (!$this->billingTransactions->contains($billingTransaction)) {
  253.             $this->billingTransactions->add($billingTransaction);
  254.             $billingTransaction->setUser($this);
  255.         }
  257.         return $this;
  258.     }
  260.     public function removeBillingTransaction(BillingTransaction $billingTransaction): self
  261.     {
  262.         if ($this->billingTransactions->removeElement($billingTransaction)) {
  263.             // set the owning side to null (unless already changed)
  264.             if ($billingTransaction->getUser() === $this) {
  265.                 $billingTransaction->setUser(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     /**
  273.      * @return Collection<int, UserProject>
  274.      */
  275.     public function getUserProjects(): Collection
  276.     {
  277.         return $this->userProjects;
  278.     }
  280.     public function addUserProject(UserProject $userProject): self
  281.     {
  282.         if (!$this->userProjects->contains($userProject)) {
  283.             $this->userProjects->add($userProject);
  284.             $userProject->setUser($this);
  285.         }
  287.         return $this;
  288.     }
  290.     public function removeUserProject(UserProject $userProject): self
  291.     {
  292.         if ($this->userProjects->removeElement($userProject)) {
  293.             // set the owning side to null (unless already changed)
  294.             if ($userProject->getUser() === $this) {
  295.                 $userProject->setUser(null);
  296.             }
  297.         }
  299.         return $this;
  300.     }
  302.     #[Ignore]
  303.     public function getMainUserProject(): UserProject
  304.     {
  305.         foreach ($this->userProjects as $project) {
  306.             if ($project->isMain()) {
  307.                 return $project;
  308.             }
  309.         }
  310.     }
  311.     
  312.     /**
  313.      * @return string|null
  314.      */
  315.     public function getVkToken(): ?string
  316.     {
  317.         return $this->vkToken;
  318.     }
  319.     
  320.     /**
  321.      * @param string|null $vkToken
  322.      */
  323.     public function setVkToken(?string $vkToken): void
  324.     {
  325.         $this->vkToken = $vkToken;
  326.     }
  327.     
  328.     /**
  329.      * @return string|null
  330.      */
  331.     public function getVkId(): ?string
  332.     {
  333.         return $this->vkId;
  334.     }
  335.     
  336.     /**
  337.      * @param string|null $vkId
  338.      */
  339.     public function setVkId(?string $vkId): void
  340.     {
  341.         $this->vkId = $vkId;
  342.     }
  343.     
  344.     /**
  345.      * @return Collection
  346.      */
  347.     public function getUserPlatforms(): Collection
  348.     {
  349.         return $this->userPlatforms;
  350.     }
  351.     
  352.     /**
  353.      * @param Collection $userPlatforms
  354.      */
  355.     public function setUserPlatforms(Collection $userPlatforms): void
  356.     {
  357.         $this->userPlatforms = $userPlatforms;
  358.     }
  359.     
  360.     public function addUserPlatform(UserPlatform $userPlatform): self
  361.     {
  362.         if (!$this->userPlatforms->contains($userPlatform)) {
  363.             $this->userPlatforms->add($userPlatform);
  364.             $userPlatform->setUser($this);
  365.         }
  366.         
  367.         return $this;
  368.     }
  369.     
  370.     public function removeUserPlatform(UserPlatform $userPlatform): self
  371.     {
  372.         if ($this->userPlatforms->removeElement($userPlatform)) {
  373.             if ($userPlatform->getUser() === $this) {
  374.                 $userPlatform->setUser(null);
  375.             }
  376.         }
  377.         
  378.         return $this;
  379.     }
  380.     
  381.     /**
  382.      * @return Collection
  383.      */
  384.     public function getUserOrd(): Collection
  385.     {
  386.         return $this->userOrd;
  387.     }
  388.     
  389.     /**
  390.      * @param Collection $userOrd
  391.      */
  392.     public function setUserOrd(Collection $userOrd): void
  393.     {
  394.         $this->userOrd = $userOrd;
  395.     }
  396.     
  397.     public function addUserOrd(UserOrd $userOrd): self
  398.     {
  399.         if (!$this->userOrd->contains($userOrd)) {
  400.             $this->userOrd->add($userOrd);
  401.             $userOrd->setUser($this);
  402.         }
  403.         
  404.         return $this;
  405.     }
  406.     
  407.     public function removeUserOrd(UserOrd $userOrd): self
  408.     {
  409.         if ($this->userOrd->removeElement($userOrd)) {
  410.             if ($userOrd->getUser() === $this) {
  411.                 $userOrd->setUser(null);
  412.             }
  413.         }
  414.         
  415.         return $this;
  416.     }
  417. }