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;
  13. #[ORM\Entity(repositoryClass: UserRepository::class)]
  14. #[ORM\UniqueConstraint(name: 'UNIQ_IDENTIFIER_EMAIL', fields: ['email'])]
  15. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     private ?int $id = null;
  23.     #[ORM\Column(length: 180)]
  24.     private ?string $email = null;
  25.     /**
  26.      * @var string[] The user roles
  27.      */
  28.     #[ORM\Column(type: 'array')]
  29.     private array $roles = [];
  31.     /**
  32.      * @var string The hashed password
  33.      */
  34.     #[ORM\Column]
  35.     private ?string $password = null;
  37.     #[ORM\OneToMany(targetEntity: Documento::class, mappedBy: 'user')]
  38.     private Collection $documentos;
  40.     #[ORM\ManyToMany(targetEntity: Cliente::class, inversedBy: 'users')]
  41.     #[ORM\JoinTable(name: 'users_clientes')]
  42.     private Collection $clientes;
  44.    
  46.     #[ORM\Column(length: 255)]
  47.     private ?string $nome = null;
  49.     #[ORM\Column(nullable: true)]
  50.     private ?array $tipoAcesso = null;
  52.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Fluxo::class)]
  53.     private Collection $fluxos;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Etapa::class)]
  56.     private Collection $etapas;
  58.     #[ORM\Column]
  59.     private ?bool $enabled = null;
  62.     public function __construct()
  63.     {
  64.         $this->documentos = new ArrayCollection();
  65.         $this->logs = new ArrayCollection();
  66.         $this->clientes = new ArrayCollection();
  67.         $this->registros = new ArrayCollection();
  68.         $this->fluxos = new ArrayCollection();
  69.         $this->etapas = new ArrayCollection();
  70.     }
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  77.     public function getEmail(): ?string
  78.     {
  79.         return $this->email;
  80.     }
  82.     public function setEmail(string $email): static
  83.     {
  84.         $this->email = $email;
  86.         return $this;
  87.     }
  89.     /**
  90.      * A visual identifier that represents this user.
  91.      *
  92.      * @see UserInterface
  93.      */
  94.     public function getUserIdentifier(): string
  95.     {
  96.         return (string) $this->email;
  97.     }
  99.     /**
  100.      * @see UserInterface
  101.      *
  102.      * @return list<string>
  103.      */
  104.     public function getRoles(): array
  105.     {
  106.         $roles = $this->roles;
  107.         // guarantee every user at least has ROLE_USER
  108.         $roles[] = 'ROLE_USER';
  110.         return array_unique($roles);
  111.     }
  113.     /**
  114.      * @param list<string> $roles
  115.      */
  116.     public function setRoles(array $roles): static
  117.     {
  118.         $this->roles = $roles;
  120.         return $this;
  121.     }
  123.     /**
  124.      * @see PasswordAuthenticatedUserInterface
  125.      */
  126.     public function getPassword(): string
  127.     {
  128.         return $this->password;
  129.     }
  131.     public function setPassword(string $password): static
  132.     {
  133.         $this->password = $password;
  135.         return $this;
  136.     }
  138.     /**
  139.      * @see UserInterface
  140.      */
  141.     public function eraseCredentials(): void
  142.     {
  143.         // If you store any temporary, sensitive data on the user, clear it here
  144.         // $this->plainPassword = null;
  145.     }
  147.     /**
  148.      * @return Collection<int, Documento>
  149.      */
  150.     public function getDocumentos(): Collection
  151.     {
  152.         return $this->documentos;
  153.     }
  155.     public function addDocumento(Documento $documento): static
  156.     {
  157.         if (!$this->documentos->contains($documento)) {
  158.             $this->documentos->add($documento);
  159.             $documento->setUser($this);
  160.         }
  162.         return $this;
  163.     }
  165.     public function removeDocumento(Documento $documento): static
  166.     {
  167.         if ($this->documentos->removeElement($documento)) {
  168.             // set the owning side to null (unless already changed)
  169.             if ($documento->getUser() === $this) {
  170.                 $documento->setUser(null);
  171.             }
  172.         }
  174.         return $this;
  175.     }
  177.     /**
  178.      * @return Collection<int, Cliente>
  179.      */
  180.     public function getClientes(): Collection
  181.     {
  182.         return $this->clientes;
  183.     }
  185.     public function addCliente(Cliente $cliente): static
  186.     {
  187.         if (!$this->clientes->contains($cliente)) {
  188.             $this->clientes->add($cliente);
  189.             $cliente->addUser($this);
  190.         }
  192.         return $this;
  193.     }
  195.     public function removeCliente(Cliente $cliente): static
  196.     {
  197.         if ($this->clientes->removeElement($cliente)) {
  198.             $cliente->removeUser($this);
  199.         }
  201.         return $this;
  202.     }
  204.   
  206.     public function getNome(): ?string
  207.     {
  208.         return $this->nome;
  209.     }
  211.     public function setNome(string $nome): static
  212.     {
  213.         $this->nome = $nome;
  215.         return $this;
  216.     }
  218.     public function getTipoAcesso(): ?array
  219.     {
  220.         return $this->tipoAcesso;
  221.     }
  223.     public function setTipoAcesso(?array $tipoAcesso): static
  224.     {
  225.         $this->tipoAcesso = $tipoAcesso;
  227.         return $this;
  228.     }
  230.     /**
  231.      * @return Collection<int, Fluxo>
  232.      */
  233.     public function getFluxos(): Collection
  234.     {
  235.         return $this->fluxos;
  236.     }
  238.     public function addFluxo(Fluxo $fluxo): static
  239.     {
  240.         if (!$this->fluxos->contains($fluxo)) {
  241.             $this->fluxos->add($fluxo);
  242.             $fluxo->setUser($this);
  243.         }
  245.         return $this;
  246.     }
  248.     public function removeFluxo(Fluxo $fluxo): static
  249.     {
  250.         if ($this->fluxos->removeElement($fluxo)) {
  251.             // set the owning side to null (unless already changed)
  252.             if ($fluxo->getUser() === $this) {
  253.                 $fluxo->setUser(null);
  254.             }
  255.         }
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return Collection<int, Etapa>
  262.      */
  263.     public function getEtapas(): Collection
  264.     {
  265.         return $this->etapas;
  266.     }
  268.     public function addEtapa(Etapa $etapa): static
  269.     {
  270.         if (!$this->etapas->contains($etapa)) {
  271.             $this->etapas->add($etapa);
  272.             $etapa->setUser($this);
  273.         }
  275.         return $this;
  276.     }
  278.     public function removeEtapa(Etapa $etapa): static
  279.     {
  280.         if ($this->etapas->removeElement($etapa)) {
  281.             // set the owning side to null (unless already changed)
  282.             if ($etapa->getUser() === $this) {
  283.                 $etapa->setUser(null);
  284.             }
  285.         }
  287.         return $this;
  288.     }
  290.     public function isEnabled(): ?bool
  291.     {
  292.         return $this->enabled;
  293.     }
  295.     public function setEnabled(bool $enabled): static
  296.     {
  297.         $this->enabled = $enabled;
  299.         return $this;
  300.     }
  302. }