src/Entity/User.php line 41

  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use App\Controller\Api\Action\User\UserMenuVisibilityAction;
  9. use App\Enum\BaseRoleEnum;
  10. use App\Repository\UserRepository;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\ORM\Mapping as ORM;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Validator\Constraints as Assert;
  18. #[ORM\Entity(
  19.     repositoryClass: UserRepository::class
  20. )]
  21. #[ORM\Table(
  22.     name: 'user'
  23. )]
  24. #[UniqueEntity(
  25.     fields: 'email',
  26.     message: 'user.email',
  27.     groups: ['registration', 'password_reset', 'admin-action-create']
  28. )]
  29. #[ApiResource(
  30.     collectionOperations: [],
  31.     itemOperations: [
  32.         'get',
  33.         'menu_visibility' => [
  34.             'access_control' => 'is_granted("ROLE_USER")',
  35.             'method' => 'PATCH',
  36.             'path' => '/users/menu/visibility/{id}',
  37.             'controller' => UserMenuVisibilityAction::class
  38.         ]
  39.     ]
  40. )]
  41. class User implements UserInterface, PasswordAuthenticatedUserInterface
  42. {
  43.     #[ORM\Id]
  44.     #[ORM\GeneratedValue]
  45.     #[ORM\Column(
  46.         type: 'integer'
  47.     )]
  48.     private ?int $id = null;
  50.     #[ORM\Column(
  51.         name: 'email',
  52.         type: 'string',
  53.         length: 180,
  54.         unique: true,
  55.         nullable: false
  56.     )]
  57.     #[Assert\NotBlank(
  58.         groups: ['registration', 'request_password_reset', 'admin-action-create']
  59.     )]
  60.     #[Assert\Email(
  61.         groups: ['password_reset', 'admin-action-create']
  62.     )]
  63.     private string $email;
  65.     #[ORM\Column(
  66.         type: 'simple_array'
  67.     )]
  68.     private array $roles = [];
  70.     #[ORM\Column(
  71.         name: 'password',
  72.         type: 'string',
  73.         nullable: false
  74.     )]
  75.     private string $password;
  77.     #[ORM\Column(
  78.         name: 'first_name',
  79.         type: 'string',
  80.         nullable: false
  81.     )]
  83.     #[Assert\NotBlank(
  84.         groups: ['registration', 'update', 'admin-action-create', 'admin-action-update']
  85.     )]
  86.     private ?string $firstName = null;
  88.     #[ORM\Column(
  89.         name: 'last_name',
  90.         type: 'string',
  91.         nullable: false
  92.     )]
  93.     #[Assert\NotBlank(
  94.         groups: ['registration', 'update', 'admin-action-create', 'admin-action-update']
  95.     )]
  96.     private ?string $lastName = null;
  98.     #[Assert\NotBlank(
  99.         groups: ['registration', 'password_reset', 'admin-action-create']
  100.     )]
  101.     #[Assert\Length(
  102.         max: 4096,
  103.         groups: ['registration', 'update', 'action']
  104.     )]
  105.     private ?string $plainPassword = null;
  107.     #[ORM\Column(
  108.         name: 'registration_token',
  109.         type: 'string',
  110.         length: 191,
  111.         nullable: true
  112.     )]
  113.     private ?string $registrationToken = null;
  115.     #[ORM\Column(
  116.         name: 'password_reset_token',
  117.         type: 'string',
  118.         length: 191,
  119.         nullable: true
  120.     )]
  121.     private ?string $passwordResetToken = null;
  123.     #[ORM\Column(
  124.         name: 'menu_visibility',
  125.         type: 'boolean',
  126.         nullable: true
  127.     )]
  128.     private ?bool $menuVisibility = false;
  130.     #[ORM\Column(
  131.         name: 'active',
  132.         type: 'boolean',
  133.         nullable: true
  134.     )]
  135.     private ?bool $active = true;
  137.     #[ORM\OneToMany(
  138.         mappedBy: 'recipient',
  139.         targetEntity: Notification::class,
  140.         cascade: ['persist'],
  141.         fetch: 'EXTRA_LAZY',
  142.         orphanRemoval: true
  143.     )]
  144.     private iterable $notification;
  146.     #[ORM\OneToMany(
  147.         mappedBy: 'user',
  148.         targetEntity: UserInstitution::class,
  149.         cascade: ['persist'],
  150.         fetch: 'EXTRA_LAZY',
  151.         orphanRemoval: true
  152.     )]
  153.     #[Assert\Valid(
  154.         groups: ['admin-action-create', 'admin-action-update']
  155.     )]
  156.     #[Assert\Count(
  157.         min: 1,
  158.         minMessage: 'user.minInstitution',
  159.         groups: ['admin-action-create', 'admin-action-update']
  160.     )]
  161.     private iterable $userInstitution;
  163.     #[ORM\OneToMany(
  164.         mappedBy: 'user',
  165.         targetEntity: ItemUser::class,
  166.         cascade: ['persist'],
  167.         fetch: 'EXTRA_LAZY',
  168.         orphanRemoval: true
  169.     )]
  170.     private ?iterable $itemUser;
  172.     #[ORM\OneToMany(
  173.         mappedBy: 'user',
  174.         targetEntity: PartnerUser::class,
  175.         cascade: ['persist', 'remove'],
  176.         fetch: 'EXTRA_LAZY',
  177.         orphanRemoval: true
  178.     )]
  179.     private ?iterable $partnerUser;
  181.     public function __construct()
  182.     {
  183.         $this->notification = new ArrayCollection();
  184.         $this->userInstitution = new ArrayCollection();
  185.         $this->itemUser = new ArrayCollection();
  186.         $this->partnerUser = new ArrayCollection();
  187.     }
  189.     public function getId(): ?int
  190.     {
  191.         return $this->id;
  192.     }
  194.     public function getEmail(): ?string
  195.     {
  196.         return $this->email;
  197.     }
  199.     public function setEmail(string $email): self
  200.     {
  201.         $this->email = $email;
  203.         return $this;
  204.     }
  206.     public function getRoles(): array
  207.     {
  208.         $roles = $this->roles;
  210.         $roles[] = BaseRoleEnum::ROLE_USER;
  212.         return array_unique($roles);
  213.     }
  215.     public function setRoles(array $roles): self
  216.     {
  217.         $this->roles = $roles;
  219.         return $this;
  220.     }
  222.     public function getPassword(): string
  223.     {
  224.         return $this->password;
  225.     }
  227.     public function setPassword(string $password): self
  228.     {
  229.         $this->password = $password;
  231.         return $this;
  232.     }
  234.     public function getFirstName(): ?string
  235.     {
  236.         return $this->firstName;
  237.     }
  239.     public function setFirstName(?string $firstName): self
  240.     {
  241.         $this->firstName = $firstName;
  243.         return $this;
  244.     }
  246.     public function getLastName(): ?string
  247.     {
  248.         return $this->lastName;
  249.     }
  251.     public function setLastName(?string $lastName): self
  252.     {
  253.         $this->lastName = $lastName;
  255.         return $this;
  256.     }
  258.     public function getFullName(): string
  259.     {
  260.         return $this->getFirstName() . ' ' . $this->getLastName();
  261.     }
  263.     public function getPlainPassword(): ?string
  264.     {
  265.         return $this->plainPassword;
  266.     }
  268.     public function setPlainPassword(?string $plainPassword): self
  269.     {
  270.         $this->plainPassword = $plainPassword;
  272.         return $this;
  273.     }
  275.     public function getRegistrationToken(): ?string
  276.     {
  277.         return $this->registrationToken;
  278.     }
  280.     public function setRegistrationToken(?string $registrationToken): self
  281.     {
  282.         $this->registrationToken = $registrationToken;
  284.         return $this;
  285.     }
  287.     public function getPasswordResetToken(): ?string
  288.     {
  289.         return $this->passwordResetToken;
  290.     }
  292.     public function setPasswordResetToken(?string $passwordResetToken): self
  293.     {
  294.         $this->passwordResetToken = $passwordResetToken;
  296.         return $this;
  297.     }
  299.     public function isMenuVisibility(): ?bool
  300.     {
  301.         return $this->menuVisibility;
  302.     }
  304.     public function setMenuVisibility(?bool $menuVisibility): self
  305.     {
  306.         $this->menuVisibility = $menuVisibility;
  308.         return $this;
  309.     }
  311.     public function getActive(): ?bool
  312.     {
  313.         return $this->active;
  314.     }
  316.     public function setActive(?bool $active): self
  317.     {
  318.         $this->active = $active;
  320.         return $this;
  321.     }
  323.     public function isNotificationsUnread(): bool
  324.     {
  325.         /** @var Notification $n */
  326.         foreach ($this->getNotification() as $n) {
  327.             if (null === $n->getReadDate()) {
  328.                 return true;
  329.             }
  330.         }
  332.         return false;
  333.     }
  335.     public function getNotification(): iterable
  336.     {
  337.         return $this->notification;
  338.     }
  340.     public function removeUserInstitution(UserInstitution $userInstitution): void
  341.     {
  342.         if (!$this->userInstitution->contains($userInstitution)) {
  343.             return;
  344.         }
  345.         $this->userInstitution->removeElement($userInstitution);
  347.         $userInstitution->setUser(null);
  348.     }
  350.     public function addUserInstitution(UserInstitution $userInstitution): void
  351.     {
  352.         if ($this->userInstitution->contains($userInstitution)) {
  353.             return;
  354.         }
  355.         $this->userInstitution[] = $userInstitution;
  357.         $userInstitution->setUser($this);
  358.     }
  360.     public function getCurrentRoleInstitution(): ?UserInstitutionRole
  361.     {
  362.         /** @var UserInstitution $userInstitution */
  363.         foreach ($this->getUserInstitution() as $userInstitution) {
  365.             /** @var UserInstitutionRole $userRoleInstitution */
  366.             foreach ($userInstitution->getRoles() as $userRoleInstitution)
  367.                 if ($userRoleInstitution->isCurrent()) {
  368.                     return $userRoleInstitution;
  369.                 }
  370.         }
  372.         return null;
  373.     }
  375.     public function getCurrentRolePartnerUser(): ?PartnerUser
  376.     {
  377.         /** @var PartnerUser $partnerUser */
  378.         foreach ($this->getPartnerUser() as $partnerUser) {
  379.             if ($partnerUser->isCurrent()) {
  380.                 return $partnerUser;
  381.             }
  382.         }
  384.         return null;
  385.     }
  387.     public function getCurrentInstitution(): ?Institution
  388.     {
  389.         $currentRoleInstitution = $this->getCurrentRoleInstitution();
  391.         return $currentRoleInstitution?->getUserInstitution()->getInstitution();
  393.     }
  395.     public function getCurrentRole(): ?Role
  396.     {
  397.         $currentRoleInstitution = $this->getCurrentRoleInstitution();
  399.         return $currentRoleInstitution?->getRole();
  400.     }
  402.     public function getUserInstitution(): iterable
  403.     {
  404.         return $this->userInstitution;
  405.     }
  407.     public function setUserInstitution(iterable $userInstitutions): self
  408.     {
  409.         $this->userInstitution = $userInstitutions;
  411.         return $this;
  412.     }
  414.     public function getItemUser(): iterable
  415.     {
  416.         return $this->itemUser;
  417.     }
  419.     public function getPartnerUser(): iterable
  420.     {
  421.         return $this->partnerUser;
  422.     }
  424.     public function addPartnerUser(PartnerUser $partnerUser): void
  425.     {
  426.         if ($this->partnerUser->contains($partnerUser)) {
  427.             return;
  428.         }
  429.         $this->partnerUser[] = $partnerUser;
  431.         $partnerUser->setUser($this);
  432.     }
  434.     public function removePartnerUser(PartnerUser $partnerUser): void
  435.     {
  436.         if (!$this->partnerUser->contains($partnerUser)) {
  437.             return;
  438.         }
  439.         $this->partnerUser->removeElement($partnerUser);
  441.         $partnerUser->setUser(null);
  442.     }
  444.     public function getSalt(): ?string
  445.     {
  446.         return null;
  447.     }
  449.     public function eraseCredentials(): void
  450.     {
  451.     }
  453.     public function getUsername(): string
  454.     {
  455.         return $this->email;
  456.     }
  458.     public function getUserIdentifier(): string
  459.     {
  460.         return $this->email;
  461.     }
  463.     public function __sleep(): array
  464.     {
  465.         return ['id', 'password', 'email'];
  466.     }
  467. }