src/Entity/User.php line 28

  1. <?php
  2. /*
  3.  *  @author Guerby Duval <info@tranzaksyon.com>
  4.  *  @link https://tranzaksyon.com
  5.  *  @copyright You are not allowed to remove this author "Guerby Duval <info@tranzaksyon.com>", the link "https://tranzaksyon.com" neither this copyright.
  6.  */
  8. namespace App\Entity;
  10. use App\Interfaces\OwnerCompanyInterface;
  11. use App\Repository\UserRepository;
  12. use App\RoleUtils;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Serializer\Annotation\Groups;
  20. use Symfony\Component\Validator\Constraints\Count;
  21. use Symfony\Component\Validator\Constraints\Email;
  22. use Symfony\Component\Validator\Constraints\Length;
  23. use Symfony\Component\Validator\Constraints\NotBlank;
  25. #[ORM\Entity(repositoryClass: UserRepository::class)]
  26. #[UniqueEntity('email')]
  27. #[UniqueEntity('username')]
  28. class User implements UserInterface, PasswordAuthenticatedUserInterface, OwnerCompanyInterface
  29. {
  30.     #[ORM\Id]
  31.     #[ORM\GeneratedValue]
  32.     #[ORM\Column]
  33.     #[Groups(['user_out'])]
  34.     private ?int $id = null;
  36.     #[ORM\Column(length: 180, unique: true)]
  37.     #[NotBlank]
  38.     #[Groups(['user_out'])]
  39.     private ?string $username = null;
  41.     #[ORM\Column]
  42.     #[NotBlank(groups: ['employee-create'])]
  43.     #[Count(min: 1, groups: ['employee-create'])]
  44.     #[Groups(['user_out'])]
  45.     private array $roles = [];
  47.     /**
  48.      * @var string The hashed password
  49.      */
  50.     #[ORM\Column]
  51.     #[NotBlank(groups: ["new-user"])]
  52.     #[Length(min: 8, groups: ["new-user"])]
  53.     private ?string $password = null;
  55.     #[ORM\Column(length: 80, unique: true)]
  56.     #[Email]
  57.     #[NotBlank]
  58.     #[Groups(['user_out'])]
  59.     private ?string $email = null;
  61.     #[ORM\Column(length: 100)]
  62.     #[NotBlank]
  63.     #[Groups(['user_out'])]
  64.     private ?string $name = null;
  66.     #[ORM\Column(length: 100)]
  67.     #[NotBlank]
  68.     #[Groups(['user_out'])]
  69.     private ?string $lastname = null;
  71.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SriInfo::class, orphanRemoval: true)]
  72.     private Collection $sriInfos;
  74.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Invoice::class)]
  75.     private Collection $invoices;
  77.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'disabledUsers')]
  78.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  79.     private ?self $disabledBy = null;
  81.     #[ORM\OneToMany(mappedBy: 'disabledBy', targetEntity: self::class)]
  82.     private Collection $disabledUsers;
  84.     #[ORM\OneToMany(mappedBy: 'disabledBy', targetEntity: SriInfo::class)]
  85.     private Collection $disableCompanies;
  87.     #[ORM\Column(length: 2000, nullable: true)]
  88.     private ?string $resetPasswordKey = null;
  90.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: Company::class, orphanRemoval: true)]
  91.     private Collection $companies;
  93.     public function __construct()
  94.     {
  95.         $this->sriInfos = new ArrayCollection();
  96.         $this->invoices = new ArrayCollection();
  97.         $this->disabledUsers = new ArrayCollection();
  98.         $this->disableCompanies = new ArrayCollection();
  99.         $this->companies = new ArrayCollection();
  100.     }
  102.     public function getId(): ?int
  103.     {
  104.         return $this->id;
  105.     }
  107.     public function getUsername(): ?string
  108.     {
  109.         return $this->username;
  110.     }
  112.     public function setUsername(string $username): self
  113.     {
  114.         $this->username = $username;
  116.         return $this;
  117.     }
  119.     /**
  120.      * A visual identifier that represents this user.
  121.      *
  122.      * @see UserInterface
  123.      */
  124.     public function getUserIdentifier(): string
  125.     {
  126.         return (string)$this->username;
  127.     }
  129.     /**
  130.      * @see UserInterface
  131.      */
  132.     public function getRoles(): array
  133.     {
  134.         $roles = $this->roles;
  135.         // guarantee every user at least has ROLE_USER
  136.         $roles[] = 'ROLE_USER';
  138.         return array_unique($roles);
  139.     }
  141.     public function setRoles(array $roles): self
  142.     {
  143.         $this->roles = $roles;
  145.         return $this;
  146.     }
  148.     /**
  149.      * @see PasswordAuthenticatedUserInterface
  150.      */
  151.     public function getPassword(): string
  152.     {
  153.         return $this->password;
  154.     }
  156.     public function setPassword(string $password): self
  157.     {
  158.         $this->password = $password;
  160.         return $this;
  161.     }
  163.     /**
  164.      * @see UserInterface
  165.      */
  166.     public function eraseCredentials()
  167.     {
  168.         // If you store any temporary, sensitive data on the user, clear it here
  169.         // $this->plainPassword = null;
  170.     }
  172.     public function getEmail(): ?string
  173.     {
  174.         return $this->email;
  175.     }
  177.     public function setEmail(string $email): self
  178.     {
  179.         $this->email = $email;
  181.         return $this;
  182.     }
  184.     public function getName(): ?string
  185.     {
  186.         return $this->name;
  187.     }
  189.     public function setName(string $name): self
  190.     {
  191.         $this->name = $name;
  193.         return $this;
  194.     }
  196.     public function getLastname(): ?string
  197.     {
  198.         return $this->lastname;
  199.     }
  201.     public function setLastname(string $lastname): self
  202.     {
  203.         $this->lastname = $lastname;
  205.         return $this;
  206.     }
  208.     public function canonicalRoles()
  209.     {
  210.         return RoleUtils::canonicalizeRoles($this->getRoles());
  211.     }
  213.     /**
  214.      * @return Collection<int, SriInfo>
  215.      */
  216.     public function getSriInfos(): Collection
  217.     {
  218.         return $this->sriInfos;
  219.     }
  221.     public function addSriInfo(SriInfo $sriInfo): self
  222.     {
  223.         if (!$this->sriInfos->contains($sriInfo)) {
  224.             $this->sriInfos->add($sriInfo);
  225.             $sriInfo->setUser($this);
  226.         }
  228.         return $this;
  229.     }
  231.     public function removeSriInfo(SriInfo $sriInfo): self
  232.     {
  233.         if ($this->sriInfos->removeElement($sriInfo)) {
  234.             // set the owning side to null (unless already changed)
  235.             if ($sriInfo->getUser() === $this) {
  236.                 $sriInfo->setUser(null);
  237.             }
  238.         }
  240.         return $this;
  241.     }
  243.     /**
  244.      * @return Collection<int, Invoice>
  245.      */
  246.     public function getInvoices(): Collection
  247.     {
  248.         return $this->invoices;
  249.     }
  251.     public function addInvoice(Invoice $invoice): self
  252.     {
  253.         if (!$this->invoices->contains($invoice)) {
  254.             $this->invoices->add($invoice);
  255.             $invoice->setUser($this);
  256.         }
  258.         return $this;
  259.     }
  261.     public function removeInvoice(Invoice $invoice): self
  262.     {
  263.         if ($this->invoices->removeElement($invoice)) {
  264.             // set the owning side to null (unless already changed)
  265.             if ($invoice->getUser() === $this) {
  266.                 $invoice->setUser(null);
  267.             }
  268.         }
  270.         return $this;
  271.     }
  273.     public function getDisabledBy(): ?self
  274.     {
  275.         return $this->disabledBy;
  276.     }
  278.     public function setDisabledBy(?self $disabledBy): self
  279.     {
  280.         $this->disabledBy = $disabledBy;
  282.         return $this;
  283.     }
  285.     /**
  286.      * @return Collection<int, self>
  287.      */
  288.     public function getDisabledUsers(): Collection
  289.     {
  290.         return $this->disabledUsers;
  291.     }
  293.     public function addDisabledUser(self $disabledUser): self
  294.     {
  295.         if (!$this->disabledUsers->contains($disabledUser)) {
  296.             $this->disabledUsers->add($disabledUser);
  297.             $disabledUser->setDisabledBy($this);
  298.         }
  300.         return $this;
  301.     }
  303.     public function removeDisabledUser(self $disabledUser): self
  304.     {
  305.         if ($this->disabledUsers->removeElement($disabledUser)) {
  306.             // set the owning side to null (unless already changed)
  307.             if ($disabledUser->getDisabledBy() === $this) {
  308.                 $disabledUser->setDisabledBy(null);
  309.             }
  310.         }
  312.         return $this;
  313.     }
  315.     /**
  316.      * @return Collection<int, SriInfo>
  317.      */
  318.     public function getDisableCompanies(): Collection
  319.     {
  320.         return $this->disableCompanies;
  321.     }
  323.     public function addDisableCompany(SriInfo $disableCompany): self
  324.     {
  325.         if (!$this->disableCompanies->contains($disableCompany)) {
  326.             $this->disableCompanies->add($disableCompany);
  327.             $disableCompany->setDisabledBy($this);
  328.         }
  330.         return $this;
  331.     }
  333.     public function removeDisableCompany(SriInfo $disableCompany): self
  334.     {
  335.         if ($this->disableCompanies->removeElement($disableCompany)) {
  336.             // set the owning side to null (unless already changed)
  337.             if ($disableCompany->getDisabledBy() === $this) {
  338.                 $disableCompany->setDisabledBy(null);
  339.             }
  340.         }
  342.         return $this;
  343.     }
  345.     public function getResetPasswordKey(): ?string
  346.     {
  347.         return $this->resetPasswordKey;
  348.     }
  350.     public function setResetPasswordKey(?string $resetPasswordKey): self
  351.     {
  352.         $this->resetPasswordKey = $resetPasswordKey;
  354.         return $this;
  355.     }
  357.     public function getSriInfo(): ?SriInfo
  358.     {
  359.         if ($this->sriInfos->count() === 0) {
  360.             return null;
  361.         }
  363.         return $this->sriInfos[0];
  364.     }
  366.     /**
  367.      * @return Collection<int, Company>
  368.      */
  369.     public function getCompanies(): Collection
  370.     {
  371.         return $this->companies;
  372.     }
  374.     public function addCompany(Company $company): static
  375.     {
  376.         if (!$this->companies->contains($company)) {
  377.             $this->companies->add($company);
  378.             $company->setOwner($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeCompany(Company $company): static
  385.     {
  386.         if ($this->companies->removeElement($company)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($company->getOwner() === $this) {
  389.                 $company->setOwner(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  395. }