src/Entity/User.php line 18

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\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. /**
  14.  * @ORM\Entity(repositoryClass=UserRepository::class)
  15.  * @UniqueEntity(fields={"email"}, message="There is already an account with this email")
  16.  * // @UniqueEntity(fields={"dni"}, message="There is already an account with this dni")
  17.  */
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface
  19. {
  20.     /** @var Array List of available roles for users. Used on forms of user */
  21.     private const ROLES_AVAILABLE = [
  22.         'user' => 'USER',
  23.         'office' => 'OFFICE',
  24.         'admin' => 'ADMIN',
  25.     ];
  27.     // public const PRUEBA_NUMEROS = [
  28.     //     'Prueba [cod]' => "1a",
  29.     //     'Pruebaa' => "2",
  30.     //     'Pruebaaa' => "3",
  31.     //     'Pruebaaaa' => "4",
  32.     // ];
  34.     /**
  35.      * @ORM\Id
  36.      * @ORM\GeneratedValue
  37.      * @ORM\Column(type="integer")
  38.      */
  39.     private $id;
  41.     /**
  42.      * @var string
  43.      *
  44.      * @ORM\Column(name="name", type="string", length=50, nullable=true)
  45.      */
  46.     private $name = '';
  48.     /**
  49.      * @var string
  50.      *
  51.      * @ORM\Column(name="surname", type="string", length=100, nullable=true)
  52.      */
  53.     private $surname = '';
  55.     /**
  56.      * @ORM\Column(type="string", length=180, unique=true)
  57.      */
  58.     private $email;
  60.     /**
  61.      * @var string
  62.      *
  63.      * @ORM\Column(name="hash_aux", type="string", length=100, nullable=true)
  64.      */
  65.     private $hashAux;
  67.     /**
  68.      * @ORM\Column(type="json")
  69.      */
  70.     private $roles = [];
  72.     /**
  73.      * @ORM\Column(type="string", length=10, nullable=true)
  74.      */
  75.     private $role_bank;
  77.     /**
  78.      * @var string The hashed password
  79.      * @ORM\Column(type="string")
  80.      */
  81.     private $password;
  83.     /**
  84.      * @var int
  85.      *
  86.      * @ORM\Column(name="active", type="integer", nullable=false)
  87.      */
  88.     private $active = '0';
  90.     /**
  91.      * @ORM\Column(type="boolean")
  92.      */
  93.     private $isVerified = false;
  95.     /**
  96.      * @ORM\Column(type="boolean")
  97.      */
  98.     private $isBanned = false;
  100.     /**
  101.      * @var string
  102.      * @ORM\Column(type="string", nullable=false, unique=true)
  103.      */
  104.     private $dni;
  106.     /**
  107.      * @var string
  108.      * @ORM\Column(type="string", nullable=true)
  109.      */
  110.     private $telephone;
  112.     /**
  113.      * @var string
  114.      * @ORM\Column(type="string", nullable=true)
  115.      */
  116.     private $address;
  118.     /**
  119.      * @var string
  120.      * @ORM\Column(type="string", nullable=true)
  121.      */
  122.     private $city;
  124.     /**
  125.      * @var string
  126.      * @ORM\Column(type="string", nullable=true)
  127.      */
  128.     private $province;
  130.     /**
  131.      * @var string
  132.      * @ORM\Column(type="string", nullable=true)
  133.      */
  134.     private $country;
  136.     /**
  137.      * @var string
  138.      * @ORM\Column(type="string", nullable=true)
  139.      */
  140.     private $zip_code;
  142.     /**
  143.      * @var string
  144.      * @ORM\Column(type="string", nullable=true)
  145.      */
  146.     private $category;
  148.     /**
  149.      * @ORM\ManyToOne(targetEntity=Institution::class, inversedBy="users")
  150.      * @ORM\JoinColumn(nullable=true)
  151.      */
  152.     private $institution;
  154.     /**
  155.      * @ORM\OneToOne(targetEntity=Ringer::class, inversedBy="user", cascade={"persist", "remove"}, fetch="EAGER")
  156.      */
  157.     private $ringer;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity=GroupUser::class, mappedBy="user_id", orphanRemoval=true, fetch="EAGER")
  161.      */
  162.     private $groupUsers;
  164.     /**
  165.      * @ORM\OneToMany(targetEntity=Group::class, mappedBy="coordinator")
  166.      */
  167.     private $coordinator_groups;
  169.     /**
  170.      * @ORM\OneToMany(targetEntity=Register::class, mappedBy="user")
  171.      */
  172.     private $registers;
  175.     public function __construct()
  176.     {
  177.         $this->roles = ['ROLE_RINGER'];
  178.         $this->groupUsers = new ArrayCollection();
  179.         $this->coordinator_groups = new ArrayCollection();
  180.         $this->registers = new ArrayCollection();
  181.     }
  182.     public function __toString()
  183.     {
  184.         return $this->email;
  185.     }
  188.     public function getId(): ?int
  189.     {
  190.         return $this->id;
  191.     }
  193.     public function getName(): ?string
  194.     {
  195.         return $this->name;
  196.     }
  198.     public function setName(string $name): self
  199.     {
  200.         $this->name = $name;
  202.         return $this;
  203.     }
  205.     public function getSurname(): ?string
  206.     {
  207.         return $this->surname;
  208.     }
  210.     public function setSurname(string $surname): self
  211.     {
  212.         $this->surname = $surname;
  214.         return $this;
  215.     }
  217.     public function getEmail(): ?string
  218.     {
  219.         return $this->email;
  220.     }
  222.     public function setEmail(string $email): self
  223.     {
  224.         $this->email = $email;
  226.         return $this;
  227.     }
  229.     public function getHashAux(): ?string
  230.     {
  231.         return $this->hashAux;
  232.     }
  234.     public function setHashAux(string $hashAux): self
  235.     {
  236.         $this->hashAux = $hashAux;
  238.         return $this;
  239.     }
  241.     /**
  242.      * A visual identifier that represents this user.
  243.      *
  244.      * @see UserInterface
  245.      */
  246.     public function getUserIdentifier(): string
  247.     {
  248.         return (string) $this->email;
  249.     }
  251.     /**
  252.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  253.      */
  254.     public function getUsername(): string
  255.     {
  256.         return (string) $this->email;
  257.     }
  259.     /**
  260.      * @see UserInterface
  261.      */
  262.     public function getRoles(): array
  263.     {
  264.         $roles = $this->roles;
  265.         // guarantee every user at least has ROLE_USER
  266.         $roles[] = 'ROLE_USER';
  268.         return array_unique($roles);
  269.     }
  271.     public function setRoles(array $roles): self
  272.     {
  273.         $this->roles = $roles;
  275.         return $this;
  276.     }
  277.     public function getRoleBank(): string
  278.     {
  279.         return $this->role_bank;
  280.     }
  282.     public function setRoleBank(?string $role_bank): self
  283.     {
  284.         $this->role_bank = $role_bank;
  286.         return $this;
  287.     }
  288.     /**
  289.      * @see PasswordAuthenticatedUserInterface
  290.      */
  291.     public function getPassword(): string
  292.     {
  293.         return $this->password;
  294.     }
  296.     public function setPassword(string $password): self
  297.     {
  298.         $this->password = $password;
  300.         return $this;
  301.     }
  303.     public function getActive(): ?int
  304.     {
  305.         return $this->active;
  306.     }
  308.     public function setActive(int $active): self
  309.     {
  310.         $this->active = $active;
  312.         return $this;
  313.     }
  315.     public function getDni(): string
  316.     {
  317.         return $this->dni;
  318.     }
  320.     public function setDni(string $dni): self
  321.     {
  322.         $this->dni = $dni;
  324.         return $this;
  325.     }
  327.     public function getTelephone(): ?string
  328.     {
  329.         return $this->telephone;
  330.     }
  332.     public function setTelephone(string $telephone): self
  333.     {
  334.         $this->telephone = $telephone;
  336.         return $this;
  337.     }
  339.     public function getAddress(): ?string
  340.     {
  341.         return $this->address;
  342.     }
  344.     public function setAddress(string $address): self
  345.     {
  346.         $this->address = $address;
  348.         return $this;
  349.     }
  351.     public function getCity(): ?string
  352.     {
  353.         return $this->city;
  354.     }
  356.     public function setCity(string $city): self
  357.     {
  358.         $this->city = $city;
  360.         return $this;
  361.     }
  363.     public function getProvince(): ?string
  364.     {
  365.         return $this->province;
  366.     }
  368.     public function setProvince(string $province): self
  369.     {
  370.         $this->province = $province;
  372.         return $this;
  373.     }
  375.     public function getCountry(): ?string
  376.     {
  377.         return $this->country;
  378.     }
  380.     public function setCountry(string $country): self
  381.     {
  382.         $this->country = $country;
  384.         return $this;
  385.     }
  387.     public function getZipcode(): ?string
  388.     {
  389.         return $this->zip_code;
  390.     }
  392.     public function setZipcode(string $zip_code): self
  393.     {
  394.         $this->zip_code = $zip_code;
  396.         return $this;
  397.     }
  399.     // public function getPrueba(): string
  400.     // {
  401.     //     return $this->prueba;
  402.     // }
  404.     // public function setPrueba(string $prueba): self
  405.     // {
  406.     //     $this->prueba = $prueba;
  408.     //     return $this;
  409.     // }
  411.     public function getCategory(): ?string
  412.     {
  413.         return $this->category;
  414.     }
  416.     public function setCategory(string $category): self
  417.     {
  418.         $this->category = $category;
  420.         return $this;
  421.     }
  423.     /**
  424.      * Returning a salt is only needed, if you are not using a modern
  425.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  426.      *
  427.      * @see UserInterface
  428.      */
  429.     public function getSalt(): ?string
  430.     {
  431.         return null;
  432.     }
  434.     /**
  435.      * @see UserInterface
  436.      */
  437.     public function eraseCredentials()
  438.     {
  439.         // If you store any temporary, sensitive data on the user, clear it here
  440.         // $this->plainPassword = null;
  441.     }
  443.     public function isVerified(): bool
  444.     {
  445.         return $this->isVerified;
  446.     }
  448.     public function setIsVerified(bool $isVerified): self
  449.     {
  450.         $this->isVerified = $isVerified;
  452.         return $this;
  453.     }
  455.     public function isBanned(): bool
  456.     {
  457.         return $this->isBanned;
  458.     }
  460.     public function setIsBanned(bool $isBanned): self
  461.     {
  462.         $this->isBanned = $isBanned;
  464.         return $this;
  465.     }
  467.     public function getRolesAvailables()
  468.     {
  469.         return self::ROLES_AVAILABLE;
  470.     }
  472.     public function getInstitution(): ?Institution
  473.     {
  474.         return $this->institution;
  475.     }
  477.     public function setInstitution(?Institution $institution): self
  478.     {
  479.         $this->institution = $institution;
  481.         return $this;
  482.     }
  484.     public function getRinger(): ?Ringer
  485.     {
  486.         return $this->ringer;
  487.     }
  489.     public function setRinger(?Ringer $ringer): self
  490.     {
  491.         $this->ringer = $ringer;
  493.         return $this;
  494.     }
  496.     /**
  497.      * @return Collection<int, GroupUser>
  498.      */
  499.     public function getGroupUsers(): Collection
  500.     {
  501.         return $this->groupUsers;
  502.     }
  504.     public function addGroupUser(GroupUser $groupUser): self
  505.     {
  506.         if (!$this->groupUsers->contains($groupUser)) {
  507.             $this->groupUsers[] = $groupUser;
  508.             $groupUser->setUserId($this);
  509.         }
  511.         return $this;
  512.     }
  514.     public function removeGroupUser(GroupUser $groupUser): self
  515.     {
  516.         if ($this->groupUsers->removeElement($groupUser)) {
  517.             // set the owning side to null (unless already changed)
  518.             if ($groupUser->getUserId() === $this) {
  519.                 $groupUser->setUserId(null);
  520.             }
  521.         }
  523.         return $this;
  524.     }
  526.     /**
  527.      * @return Collection<int, Group>
  528.      */
  529.     public function getCoordinatorGroups(): Collection
  530.     {
  531.         return $this->coordinator_groups;
  532.     }
  534.     public function addCoordinatorGroup(Group $coordinatorGroup): self
  535.     {
  536.         if (!$this->coordinator_groups->contains($coordinatorGroup)) {
  537.             $this->coordinator_groups[] = $coordinatorGroup;
  538.             $coordinatorGroup->setCoordinator($this);
  539.         }
  541.         return $this;
  542.     }
  544.     public function removeCoordinatorGroup(Group $coordinatorGroup): self
  545.     {
  546.         if ($this->coordinator_groups->removeElement($coordinatorGroup)) {
  547.             // set the owning side to null (unless already changed)
  548.             if ($coordinatorGroup->getCoordinator() === $this) {
  549.                 $coordinatorGroup->setCoordinator(null);
  550.             }
  551.         }
  553.         return $this;
  554.     }
  556.     /**
  557.      * @return Collection<int, Register>
  558.      */
  559.     public function getRegisters(): Collection
  560.     {
  561.         return $this->registers;
  562.     }
  564.     public function addRegister(Register $register): self
  565.     {
  566.         if (!$this->registers->contains($register)) {
  567.             $this->registers[] = $register;
  568.             $register->setUser($this);
  569.         }
  571.         return $this;
  572.     }
  574.     public function removeRegister(Register $register): self
  575.     {
  576.         if ($this->registers->removeElement($register)) {
  577.             // set the owning side to null (unless already changed)
  578.             if ($register->getUser() === $this) {
  579.                 $register->setUser(null);
  580.             }
  581.         }
  583.         return $this;
  584.     }
  585. }
  587. /**
  588.  * @var string
  589.  *
  590.  * @ORM\Column(name="role", type="string", length=10, nullable=false)
  591.  */
  592. // private $role;
  593. // public function getRole(): ?string
  594. // {
  595. //     return $this->role;
  596. // }
  598. // public function setRole(string $role): self
  599. // {
  600. //     $this->role = $role;
  602. //     return $this;
  603. // }