src/Entity/User.php line 16

Open in your IDE?
  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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[ORM\Table(name: '`user`')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     public const TYPE_ADMIN = "ADMIN";
  19.     public const TYPE_USER = "USER";
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column(type: 'integer')]
  24.     #[Groups(['list'])]
  25.     private ?int $id;
  27.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  28.     #[Groups(['list'])]
  29.     private ?string $email;
  31.     #[ORM\Column(type: 'boolean')]
  32.     #[Groups(['list'])]
  33.     private ?string $superUser;
  35.     #[ORM\Column(type: 'string', length: 10)]
  36.     #[Groups(['list'])]
  37.     private ?string $userType;
  39.     #[ORM\Column(type: 'json')]
  40.     private array $roles = [];
  42.     #[ORM\Column(type: 'string')]
  43.     private string $password;
  45.     #[ORM\Column(type: 'datetime')]
  46.     private ?\DateTimeInterface $timeCreated;
  48.     #[ORM\Column(type: 'boolean')]
  49.     private ?bool $isDeleted;
  51.     #[ORM\OneToOne(mappedBy: 'user', targetEntity: UserInfo::class)]
  52.     private ?UserInfo $userInfo;
  54.     #[ORM\ManyToMany(targetEntity: UserGroup::class)]
  55.     #[ORM\JoinTable(name: 'users_groups')]
  56.     private $groups;
  58.     #[ORM\ManyToMany(targetEntity: Department::class)]
  59.     #[ORM\JoinTable(name: 'users_departments')]
  60.     private $departments;
  62.     #[ORM\ManyToMany(targetEntity: Degree::class)]
  63.     #[ORM\JoinTable(name: 'users_degrees')]
  64.     private $degrees;
  66.     #[ORM\ManyToMany(targetEntity: GlobalConstant::class)]
  67.     #[ORM\JoinTable(name: 'users_global_constants')]
  68.     private $globalConstants;
  70.     #[ORM\ManyToMany(targetEntity: Sector::class)]
  71.     #[ORM\JoinTable(name: 'users_sectors')]
  72.     private $sectors;
  74.     public function __construct()
  75.     {
  76.         $this->groups = new ArrayCollection();
  77.         $this->departments = new ArrayCollection();
  78.         $this->degrees = new ArrayCollection();
  79.         $this->globalConstants = new ArrayCollection();
  80.         $this->sectors = new ArrayCollection();
  81.     }
  83.     public function getId(): ?int
  84.     {
  85.         return $this->id;
  86.     }
  88.     public function getEmail(): ?string
  89.     {
  90.         return $this->email;
  91.     }
  93.     public function setEmail(string $email): self
  94.     {
  95.         $this->email = $email;
  97.         return $this;
  98.     }
  100.     /**
  101.      * A visual identifier that represents this user.
  102.      *
  103.      * @see UserInterface
  104.      */
  105.     public function getUserIdentifier(): string
  106.     {
  107.         return (string)$this->email;
  108.     }
  110.     /**
  111.      * @see UserInterface
  112.      */
  113.     public function getRoles(): array
  114.     {
  115.         $roles = $this->roles;
  116.         // guarantee every user at least has ROLE_USER
  117.         $roles[] = 'ROLE_USER';
  119.         if ($this->userType === self::TYPE_ADMIN) {
  120.             $roles[] = 'ROLE_ADMIN';
  121.             if ($this->getSuperUser()) {
  122.                 $roles[] = 'ROLE_SUPER_USER';
  123.             }
  124.             foreach ($this->getGroups() as $group) {
  125.                 foreach ($group->getRoles() as $role) {
  126.                     $roles[] = 'ROLE_' . $role;
  127.                 }
  128.             }
  129.         }
  131.         return array_unique($roles);
  132.     }
  134.     public function setRoles(array $roles): self
  135.     {
  136.         $this->roles = $roles;
  138.         return $this;
  139.     }
  141.     /**
  142.      * @see PasswordAuthenticatedUserInterface
  143.      */
  144.     public function getPassword(): string
  145.     {
  146.         return $this->password;
  147.     }
  149.     public function setPassword(string $password): self
  150.     {
  151.         $this->password = $password;
  153.         return $this;
  154.     }
  156.     /**
  157.      * @see UserInterface
  158.      */
  159.     public function eraseCredentials()
  160.     {
  161.         // If you store any temporary, sensitive data on the user, clear it here
  162.         // $this->plainPassword = null;
  163.     }
  165.     public function getTimeCreated(): ?\DateTimeInterface
  166.     {
  167.         return $this->timeCreated;
  168.     }
  170.     public function setTimeCreated(\DateTimeInterface $timeCreated): self
  171.     {
  172.         $this->timeCreated = $timeCreated;
  174.         return $this;
  175.     }
  177.     public function getIsDeleted(): ?bool
  178.     {
  179.         return $this->isDeleted;
  180.     }
  182.     public function setIsDeleted(bool $isDeleted): self
  183.     {
  184.         $this->isDeleted = $isDeleted;
  186.         return $this;
  187.     }
  189.     public function getUserType(): ?string
  190.     {
  191.         return $this->userType;
  192.     }
  194.     public function setUserType(string $userType): self
  195.     {
  196.         $this->userType = $userType;
  198.         return $this;
  199.     }
  201.     /**
  202.      * @return Collection<int, UserGroup>
  203.      */
  204.     public function getGroups(): Collection
  205.     {
  206.         return $this->groups;
  207.     }
  209.     public function addGroup(UserGroup $group): self
  210.     {
  211.         if (!$this->groups->contains($group)) {
  212.             $this->groups[] = $group;
  213.         }
  215.         return $this;
  216.     }
  218.     public function removeGroup(UserGroup $group): self
  219.     {
  220.         $this->groups->removeElement($group);
  222.         return $this;
  223.     }
  225.     public function getSuperUser(): ?bool
  226.     {
  227.         return $this->superUser;
  228.     }
  230.     public function setSuperUser(bool $superUser): self
  231.     {
  232.         $this->superUser = $superUser;
  234.         return $this;
  235.     }
  237.     public function getUserInfo(): ?UserInfo
  238.     {
  239.         return $this->userInfo;
  240.     }
  242.     public function setUserInfo(?UserInfo $userInfo): self
  243.     {
  244.         // unset the owning side of the relation if necessary
  245.         if ($userInfo === null && $this->userInfo !== null) {
  246.             $this->userInfo->setUser(null);
  247.         }
  249.         // set the owning side of the relation if necessary
  250.         if ($userInfo !== null && $userInfo->getUser() !== $this) {
  251.             $userInfo->setUser($this);
  252.         }
  254.         $this->userInfo = $userInfo;
  256.         return $this;
  257.     }
  259.     public function isSuperUser(): ?bool
  260.     {
  261.         return $this->superUser;
  262.     }
  264.     public function isIsDeleted(): ?bool
  265.     {
  266.         return $this->isDeleted;
  267.     }
  269.     /**
  270.      * @return Collection<int, Department>
  271.      */
  272.     public function getDepartments(): Collection
  273.     {
  274.         return $this->departments;
  275.     }
  277.     public function addDepartment(Department $department): self
  278.     {
  279.         if (!$this->departments->contains($department)) {
  280.             $this->departments[] = $department;
  281.         }
  283.         return $this;
  284.     }
  286.     public function removeDepartment(Department $department): self
  287.     {
  288.         $this->departments->removeElement($department);
  290.         return $this;
  291.     }
  293.     /**
  294.      * @return Collection<int, Degree>
  295.      */
  296.     public function getDegrees(): Collection
  297.     {
  298.         return $this->degrees;
  299.     }
  301.     public function addDegree(Degree $degree): self
  302.     {
  303.         if (!$this->degrees->contains($degree)) {
  304.             $this->degrees->add($degree);
  305.         }
  307.         return $this;
  308.     }
  310.     public function removeDegree(Degree $degree): self
  311.     {
  312.         $this->degrees->removeElement($degree);
  314.         return $this;
  315.     }
  317.     /**
  318.      * @return Collection<int, GlobalConstant>
  319.      */
  320.     public function getGlobalConstant(): Collection
  321.     {
  322.         return $this->globalConstants;
  323.     }
  325.     public function addGlobalConstant(GlobalConstant $globalConstant): self
  326.     {
  327.         if (!$this->globalConstants->contains($globalConstant)) {
  328.             $this->globalConstants->add($globalConstant);
  329.         }
  331.         return $this;
  332.     }
  334.     public function removeGlobalConstant(GlobalConstant $globalConstant): self
  335.     {
  336.         $this->globalConstants->removeElement($globalConstant);
  338.         return $this;
  339.     }
  341.     /**
  342.      * @return Collection<int, GlobalConstant>
  343.      */
  344.     public function getGlobalConstants(): Collection
  345.     {
  346.         return $this->globalConstants;
  347.     }
  349.     /**
  350.      * @return Collection<int, Sector>
  351.      */
  352.     public function getSector(): Collection
  353.     {
  354.         return $this->sector;
  355.     }
  357.     public function addSector(Sector $sector): self
  358.     {
  359.         if (!$this->sector->contains($sector)) {
  360.             $this->sector->add($sector);
  361.         }
  363.         return $this;
  364.     }
  366.     public function removeSector(Sector $sector): self
  367.     {
  368.         $this->sector->removeElement($sector);
  370.         return $this;
  371.     }
  373.     /**
  374.      * @return Collection<int, Sector>
  375.      */
  376.     public function getSectors(): Collection
  377.     {
  378.         return $this->sectors;
  379.     }
  380. }