src/Entity/User.php line 71

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  8. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  10. use ApiPlatform\Metadata\ApiResource;
  11. use ApiPlatform\Metadata\Get;
  12. use ApiPlatform\Metadata\GetCollection;
  13. use ApiPlatform\Metadata\Delete;
  14. use ApiPlatform\Metadata\Post;
  15. use ApiPlatform\Metadata\Put;
  16. use Symfony\Component\Serializer\Annotation\Groups;
  17. use App\Controller\Api\AdminController;
  18. use App\Controller\Api\AuthController;
  19. use App\Controller\Api\UserController;
  21. #[ORM\Entity(repositoryClass: UserRepository::class)]
  22. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  23. #[ApiResource(
  24.     normalizationContext: ['groups' => ['user:read']],
  25.     denormalizationContext: ['groups' => ['user:write']],
  26.     operations: [
  27.         new Get(
  28.             name: 'auth_user',
  29.             routeName: 'api_auth_user',
  30.             controller: AuthController::class
  31.         ),
  32.         // new GetCollection(security: 'is_granted("ROLE_SUPER_ADMIN")'),
  33.         new GetCollection(
  34.             name: 'users',
  35.             routeName: 'api_users',
  36.             controller: UserController::class,
  37.             security: 'is_granted("ROLE_ADMIN")'
  38.         ),
  39.         new GetCollection(
  40.             name: 'users',
  41.             routeName: 'api_users_employees',
  42.             controller: UserController::class,
  43.             security: 'is_granted("ROLE_ADMIN")'
  44.         ),
  45.         new Delete(security: 'is_granted("ROLE_SUPER_ADMIN")'),
  46.         new Post(
  47.             name: 'user',
  48.             routeName: 'api_user',
  49.             controller: UserController::class
  50.         ),
  51.         new Post(
  52.             name: 'reset_token',
  53.             routeName: 'api_user_reset_token',
  54.             controller: AuthController::class
  55.         ),
  56.         new Post(
  57.             name: 'reset_password',
  58.             routeName: 'api_user_reset_password',
  59.             controller: AuthController::class
  60.         ),
  61.         new Post(security: 'is_granted("ROLE_SUPER_ADMIN") or is_granted("ROLE_ADMIN")'),
  62.         new Put(
  63.             name: 'user_edit',
  64.             routeName: 'api_user_edit',
  65.             controller: UserController::class,
  66.             security: 'is_granted("ROLE_SUPER_ADMIN") or is_granted("ROLE_ADMIN")'
  67.         )
  68.     ],
  69.     paginationEnabled: false
  70. )]
  71. class User implements UserInterface, PasswordAuthenticatedUserInterface
  72. {
  73.     #[ORM\Id]
  74.     #[ORM\GeneratedValue]
  75.     #[ORM\Column]
  76.     #[Groups(['user:read', 'invoice:read', 'invoiceDetail:read'])]
  77.     private ?int $id = null;
  79.     #[ORM\Column(length: 180, unique: true)]
  80.     #[Groups(['user:read', 'user:write', 'invoice:read', 'invoiceDetail:read'])]
  81.     private ?string $email = null;
  83.     #[ORM\Column]
  84.     #[Groups(['user:read', 'user:write', 'invoice:read', 'invoiceDetail:read'])]
  85.     private array $roles = [];
  87.     #[ORM\Column(type: 'integer')]
  88.     #[Groups(['user:read', 'user:write', 'invoice:read', 'invoiceDetail:read'])]
  89.     private ?int $status = 1;
  91.     #[ORM\Column(type: 'text', length: 65535, nullable: true)]
  92.     private ?string $reset_password_token = null;
  94.     #[ORM\OneToOne(targetEntity: Employee::class, inversedBy: 'user')]
  95.     #[ORM\JoinColumn(name: 'employee_id', referencedColumnName: 'id', nullable: true)]
  96.     #[Groups(['user:read', 'user:write'])]
  97.     private ?Employee $employee = null;
  99.     /**
  100.      * @var string The hashed password
  101.      */
  102.     #[ORM\Column]
  103.     #[Groups(['user:write'])]
  104.     private ?string $password = null;
  106.     public function getId(): ?int
  107.     {
  108.         return $this->id;
  109.     }
  111.     public function getEmail(): ?string
  112.     {
  113.         return $this->email;
  114.     }
  116.     public function setEmail(string $email): self
  117.     {
  118.         $this->email = $email;
  120.         return $this;
  121.     }
  123.     public function getStatus(): ?int
  124.     {
  125.         return $this->status;
  126.     }
  128.     public function setStatus(int $status): self
  129.     {
  130.         $this->status = $status;
  132.         return $this;
  133.     }
  135.     public function getResetPasswordToken(): ?string
  136.     {
  137.         return $this->reset_password_token;
  138.     }
  140.     public function setResetPasswordToken(string $reset_password_token): self
  141.     {
  142.         $this->reset_password_token = $reset_password_token;
  144.         return $this;
  145.     }
  147.     /**
  148.      * A visual identifier that represents this user.
  149.      *
  150.      * @see UserInterface
  151.      */
  152.     public function getUserIdentifier(): string
  153.     {
  154.         return (string) $this->email;
  155.     }
  157.     /**
  158.      * @see UserInterface
  159.      */
  160.     public function getRoles(): array
  161.     {
  162.         $roles = $this->roles;
  163.         // guarantee every user at least has ROLE_USER
  164.         $roles[] = 'ROLE_USER';
  166.         return array_unique($roles);
  167.     }
  169.     public function setRoles(array $roles): self
  170.     {
  171.         $this->roles = $roles;
  173.         return $this;
  174.     }
  176.     /**
  177.      * @see PasswordAuthenticatedUserInterface
  178.      */
  179.     public function getPassword(): string
  180.     {
  181.         return $this->password;
  182.     }
  184.     public function setHashedPassword(string $plainPassword): self
  185.     {
  186.         $this->password = password_hash($plainPassword, PASSWORD_BCRYPT);
  188.         return $this;
  189.     }
  191.     public function setPassword(string $plainPassword): self
  192.     {
  193.         if (!password_get_info($plainPassword)['algo']) {
  194.             $this->setHashedPassword($plainPassword);
  195.         }
  197.         return $this;
  198.     }
  200.     public function getEmployee(): ?Employee
  201.     {
  202.         return $this->employee;
  203.     }
  205.     public function setEmployee(?Employee $employee): self
  206.     {
  207.         if ($employee === null && $this->employee !== null) {
  208.             $this->employee->setUser(null);
  209.         }
  211.         if ($employee !== null && $employee->getUser() !== $this) {
  212.             $employee->setUser($this);
  213.         }
  215.         $this->employee = $employee;
  217.         return $this;
  218.     }
  220.     /**
  221.      * @see UserInterface
  222.      */
  223.     public function eraseCredentials()
  224.     {
  225.         // If you store any temporary, sensitive data on the user, clear it here
  226.         // $this->plainPassword = null;
  227.     }
  228. }