src/Entity/User.php line 24

  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\EquatableInterface;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Symfony\Component\Validator\Context\ExecutionContextInterface;
  15. use App\Entity\UserPenalty;
  16. use App\Entity\Centers;
  19. #[ORM\Entity(repositoryClass: UserRepository::class)]
  20. #[UniqueEntity(fields: ['username'])]
  21. #[UniqueEntity(fields: ['email'])]
  22. #[UniqueEntity(fields: ['dni'])]
  24. class User implements UserInterface, EquatableInterface, PasswordAuthenticatedUserInterface
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(length: 180, unique: true)]
  32.     #[Assert\NotBlank(message: 'El nombre de usuario es obligatorio')]
  33.     private ?string $username = null;
  35.     #[ORM\Column(type: 'json')]
  36.     private array $roles = [];
  38.     #[ORM\Column(length: 50)]
  39.     #[Assert\NotBlank(message: 'El nombre es obligatorio')]
  40.     private ?string $nomComplet= null;
  42.     #[ORM\Column(length: 10, unique: true)]
  43.     #[Assert\NotBlank(message: 'El DNI/NIE es obligarorio')]
  44.     private ?string $dni= null;
  46.     #[ORM\Column(length: 250,nullable: true)]
  47.     private ?string $address= null;
  49.     #[ORM\Column(length: 50,nullable: true)]
  50.     private ?string $phone= null;
  52.     #[ORM\Column(length: 50,nullable: true)]
  53.     private ?string $notes= null;
  55.     #[ORM\Column( length: 100, unique: true)]
  56.     #[Assert\NotBlank(message: 'El campo correo no puede estar vacío')]
  57.     #[Assert\Email(message: 'Email incorrecto')]
  58.     private ?string $email= null;
  60.     #[ORM\Column]
  61.     private ?bool $valid = null;
  63.     #[ORM\Column]
  64.     private ?bool $deleted = null;
  66.     #[ORM\Column( length: 255)]
  67.     private ?string $password = null;
  70.     #[ORM\Column(type: 'boolean')]
  71.     private ?bool $admin = null;
  74.     #[ORM\OneToMany(mappedBy: 'userId', targetEntity: Registrations::class, orphanRemoval: true)]
  75.     private Collection $registrations;
  77.     #[ORM\OneToMany(mappedBy: 'creatorUserId', targetEntity: Attendance::class)]
  78.     private Collection $attendances;
  80.     #[ORM\ManyToMany(targetEntity: Events::class, mappedBy: 'courseUser')]
  81.     private Collection $events;
  83.     #[ORM\ManyToMany(targetEntity: Events::class, mappedBy: 'managerUsers')]
  84.     private Collection $managedEvents;
  86.     #[ORM\Column(length: 255, nullable: true)]
  87.     private ?string $surname = null;
  89.     #[ORM\Column(length: 12, nullable: true)]
  90.     private ?string $customFilterYear = null;
  92.     #[ORM\Column(type: 'string', length: 64, nullable: true)]
  93.     private ?string $activationToken = null;
  95.     #[ORM\Column(type: 'boolean')]
  96.     private bool $active = false;
  98.     #[ORM\ManyToOne(inversedBy: 'managementUsers')]
  99.     #[ORM\JoinColumn(nullable: true, onDelete: 'SET NULL')]
  100.     private ?Centers $managementCenter = null;
  102.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  103.     private bool $canManageEventRequestsAndRegistrations = false;
  105.     public function __construct()
  106.     {
  107.        
  108.         $this->registrations = new ArrayCollection();
  109.         $this->attendances = new ArrayCollection();
  110.         $this->events = new ArrayCollection();
  111.         $this->managedEvents = new ArrayCollection();
  112.         $this->eventRequests = new ArrayCollection();
  113.         $this->penalties = new ArrayCollection();
  115.     }
  117.     public function getId(): ?int
  118.     {
  119.         return $this->id;
  120.     }
  122.     /**
  123.      * A visual identifier that represents this user.
  124.      *
  125.      * @see UserInterface
  126.      */
  127.     public function getUsername(): string
  128.     {
  129.         return (string) $this->username;
  130.     }
  132.     public function getUserIdentifier(): string
  133.     {
  134.         return (string) $this->username;
  135.     }
  137.     public function setUsername($username): self
  138.     {
  139.         $this->username = $username;
  141.         return $this;
  142.     }
  144.     /**
  145.      * @see UserInterface
  146.      */
  147.     public function getRoles(): array
  148.     {
  149.         return array_values(array_unique($this->roles));
  150.     }
  152.     public function setRoles(array $roles): self
  153.     {
  154.         $this->roles = array_values(array_unique($roles));
  156.         return $this;
  157.     }
  159.     /**
  160.      * @see UserInterface
  161.      */
  162.     public function getPassword(): ?string
  163.     {
  164.         return $this->password;
  165.     }
  167.     /**
  168.      * @see UserInterface
  169.      */
  170.     public function eraseCredentials()
  171.     {
  172.         // If you store any temporary, sensitive data on the user, clear it here
  173.         // $this->plainPassword = null;
  174.     }
  176.     public function getNomComplet(): ?string
  177.     {
  178.         return $this->nomComplet;
  179.     }
  181.     public function setNomComplet($nomComplet): self
  182.     {
  183.         $this->nomComplet = $nomComplet;
  185.         return $this;
  186.     }
  188.     public function getEmail(): ?string
  189.     {
  190.         return $this->email;
  191.     }
  193.     public function setEmail($email): self
  194.     {
  195.         $this->email = $email;
  197.         return $this;
  198.     }
  200.     public function getPhone(): ?string
  201.     {
  202.         return $this->phone;
  203.     }
  205.     public function setPhone($phone): self
  206.     {
  207.         $this->phone = $phone;
  209.         return $this;
  210.     }
  212.     public function getNotes(): ?string
  213.     {
  214.         return $this->notes;
  215.     }
  217.     public function setNotes($notes): self
  218.     {
  219.         $this->notes = $notes;
  220.         
  221.         return $this;
  222.     }
  224.     public function getAddress(): ?string
  225.     {
  226.         return $this->address;
  227.     }
  229.     public function setAddress($address): self
  230.     {
  231.         $this->address = $address;
  232.         
  233.         return $this;
  234.     }
  236.     public function getDni(): ?string
  237.     {
  238.         return $this->dni;
  239.     }
  241.     public function setDni($dni): self
  242.     {
  243.         $this->dni = $dni;
  245.         return $this;
  246.     }
  247.     public function isValid(): ?bool
  248.     {
  249.         return $this->valid;
  250.     }
  252.     public function setValid(bool $valid): self
  253.     {
  254.         $this->valid = $valid;
  256.         return $this;
  257.     }
  259.     public function isDeleted(): ?bool
  260.     {
  261.         return $this->deleted;
  262.     }
  264.     public function setDeleted(bool $deleted): self
  265.     {
  266.         $this->deleted = $deleted;
  268.         return $this;
  269.     }
  271.     public function setPassword($password): self
  272.     {
  273.         $this->password = $password;
  275.         return $this;
  276.     }
  279.     public function getAvatarUrl(): string
  280.     {
  281.         return "/avatar/".urlencode((string)$this->nomComplet);
  282.     }
  284.     public function getColorCode(): string
  285.     {
  286.         $code = dechex(crc32($this->getUsername()));
  287.         $code = substr($code, 0, 6);
  289.         return '#'.$code;
  290.     }
  292.     #[Assert\Callback]
  293.     public function validate(ExecutionContextInterface $context, $payload)
  294.     {
  295.         /*if (strlen($this->password)< 3){
  296.             $context->buildViolation('Mot de passe trop court')
  297.                 ->atPath('justpassword')
  298.                 ->addViolation();
  299.         }*/
  300.     }
  302.     public function __toString(): string
  303.     {
  304.         return "$this->nomComplet ($this->id)";
  305.     }
  307.     public function isAdmin(): ?bool
  308.     {
  309.         return $this->admin;
  310.     }
  312.     public function setAdmin(bool $admin): self
  313.     {
  314.         $this->admin = $admin;
  316.         return $this;
  317.     }
  319.     public function isEqualTo(UserInterface $user): bool
  320.     {
  321.         if ($user instanceof User) {
  322.             return $this->isValid() && !$this->isDeleted() && $this->getPassword() == $user->getPassword() && $this->getUsername() == $user->getUsername()
  323.                 && $this->getEmail() == $user->getEmail();
  324.         }
  326.         return false;
  327.     }
  329.     /**
  330.      * @return mixed
  331.      */
  332.     public function getSalt(): ?string
  333.     {
  334.         //not used here
  335.         return null;
  336.     }
  338.     /**
  339.      * @return Collection<int, Registrations>
  340.      */
  341.     public function getRegistrations(): Collection
  342.     {
  343.         return $this->registrations;
  344.     }
  346.     /**
  347.      * @return Collection<int, Registrations>
  348.      */
  349.     public function getActiveRegistrations(): Collection
  350.     {
  351.         return $this->registrations->filter(static function (Registrations $registration): bool {
  352.             return (bool) $registration->isActive();
  353.         });
  354.     }
  356.     public function addRegistration(Registrations $registration): static
  357.     {
  358.         if (!$this->registrations->contains($registration)) {
  359.             $this->registrations->add($registration);
  360.             $registration->setUserId($this);
  361.         }
  363.         return $this;
  364.     }
  366.     public function removeRegistration(Registrations $registration): static
  367.     {
  368.         if ($this->registrations->removeElement($registration)) {
  369.             // set the owning side to null (unless already changed)
  370.             if ($registration->getUserId() === $this) {
  371.                 $registration->setUserId(null);
  372.             }
  373.         }
  375.         return $this;
  376.     }
  378.     /**
  379.      * @return Collection<int, Attendance>
  380.      */
  381.     public function getAttendances(): Collection
  382.     {
  383.         return $this->attendances;
  384.     }
  386.     public function addAttendance(Attendance $attendance): static
  387.     {
  388.         if (!$this->attendances->contains($attendance)) {
  389.             $this->attendances->add($attendance);
  390.             $attendance->setCreatorUserId($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removeAttendance(Attendance $attendance): static
  397.     {
  398.         if ($this->attendances->removeElement($attendance)) {
  399.             // set the owning side to null (unless already changed)
  400.             if ($attendance->getCreatorUserId() === $this) {
  401.                 $attendance->setCreatorUserId(null);
  402.             }
  403.         }
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection<int, Events>
  410.      */
  411.     public function getEvents(): Collection
  412.     {
  413.         return $this->events;
  414.     }
  416.     public function addEvent(Events $event): static
  417.     {
  418.         if (!$this->events->contains($event)) {
  419.             $this->events->add($event);
  420.             $event->addCourseUser($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removeEvent(Events $event): static
  427.     {
  428.         if ($this->events->removeElement($event)) {
  429.             $event->removeCourseUser($this);
  430.         }
  432.         return $this;
  433.     }
  435.     /**
  436.      * @return Collection<int, Events>
  437.      */
  438.     public function getManagedEvents(): Collection
  439.     {
  440.         return $this->managedEvents;
  441.     }
  443.     public function addManagedEvent(Events $managedEvent): static
  444.     {
  445.         if (!$this->managedEvents->contains($managedEvent)) {
  446.             $this->managedEvents->add($managedEvent);
  447.             $managedEvent->addManagerUser($this);
  448.         }
  450.         return $this;
  451.     }
  453.     public function removeManagedEvent(Events $managedEvent): static
  454.     {
  455.         if ($this->managedEvents->removeElement($managedEvent)) {
  456.             $managedEvent->removeManagerUser($this);
  457.         }
  459.         return $this;
  460.     }
  462.     public function getSurname(): ?string
  463.     {
  464.         return $this->surname;
  465.     }
  467.     public function setSurname(?string $surname): static
  468.     {
  469.         $this->surname = $surname;
  471.         return $this;
  472.     }
  474.     public function getCustomFilterYear(): ?string
  475.     {
  476.         return $this->customFilterYear;
  477.     }
  479.     public function setCustomFilterYear(?string $customFilterYear): static
  480.     {
  481.         $this->customFilterYear = $customFilterYear;
  483.         return $this;
  484.     }
  486.     #[ORM\OneToOne(mappedBy: 'user', cascade: ['persist', 'remove'])]
  487.     private ?UserProfile $profile = null;
  489.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: EventRequest::class, orphanRemoval: true)]
  490.     private Collection $eventRequests;
  492.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserPenalty::class, orphanRemoval: true)]
  493.     private Collection $penalties;
  495.     public function getProfile(): ?UserProfile
  496.     {
  497.         return $this->profile;
  498.     }
  500.     public function setProfile(?UserProfile $profile): self
  501.     {
  502.         $this->profile = $profile;
  504.         if ($profile && $profile->getUser() !== $this) {
  505.             $profile->setUser($this);
  506.         }
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection<int, EventRequest>
  513.      */
  514.     public function getEventRequests(): Collection
  515.     {
  516.         return $this->eventRequests;
  517.     }
  519.     /**
  520.      * @return Collection<int, UserPenalty>
  521.      */
  522.     public function getPenalties(): Collection
  523.     {
  524.         return $this->penalties;
  525.     }
  527.     public function addEventRequest(EventRequest $eventRequest): static
  528.     {
  529.         if (!$this->eventRequests->contains($eventRequest)) {
  530.             $this->eventRequests->add($eventRequest);
  531.             $eventRequest->setUser($this);
  532.         }
  534.         return $this;
  535.     }
  537.     public function removeEventRequest(EventRequest $eventRequest): static
  538.     {
  539.         if ($this->eventRequests->removeElement($eventRequest)) {
  540.             // set the owning side to null (unless already changed)
  541.             if ($eventRequest->getUser() === $this) {
  542.                 $eventRequest->setUser(null);
  543.             }
  544.         }
  546.         return $this;
  547.     }
  549.     public function isActive(): bool
  550.     {
  551.         return $this->active;
  552.     }
  554.     public function setActive(bool $active): self
  555.     {
  556.         $this->active = $active;
  557.         return $this;
  558.     }
  560.     public function getActivationToken(): ?string
  561.     {
  562.         return $this->activationToken;
  563.     }
  565.     public function setActivationToken(?string $activationToken): self
  566.     {
  567.         $this->activationToken = $activationToken;
  568.         return $this;
  569.     }
  570.     public function isEnabled(): bool
  571.     {
  572.         return $this->active && !$this->deleted;
  573.     }
  575.     public function getManagementCenter(): ?Centers
  576.     {
  577.         return $this->managementCenter;
  578.     }
  580.     public function setManagementCenter(?Centers $managementCenter): self
  581.     {
  582.         $this->managementCenter = $managementCenter;
  584.         return $this;
  585.     }
  587.     public function canManageEventRequestsAndRegistrations(): bool
  588.     {
  589.         return $this->canManageEventRequestsAndRegistrations;
  590.     }
  592.     public function isCanManageEventRequestsAndRegistrations(): bool
  593.     {
  594.         return $this->canManageEventRequestsAndRegistrations;
  595.     }
  597.     public function setCanManageEventRequestsAndRegistrations(bool $canManageEventRequestsAndRegistrations): self
  598.     {
  599.         $this->canManageEventRequestsAndRegistrations = $canManageEventRequestsAndRegistrations;
  601.         return $this;
  602.     }
  605. }