src/Entity/Customer.php line 78

  1. <?php
  2. namespace App\Entity;
  4. use Doctrine\ORM\Mapping as ORM,
  5.     Doctrine\DBAL\Types\Types,
  6.     Doctrine\Common\Collections\ArrayCollection,
  7.     Doctrine\Common\Collections\Collection;
  9. use Symfony\Component\Serializer\Annotation\Groups,
  10.     Symfony\Component\Validator\Constraints as Assert,
  11.     Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface,
  12.     Symfony\Component\Security\Core\User\UserInterface,
  13.     Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface,
  14.     Symfony\Component\Validator\Constraint;
  16. use ApiPlatform\Metadata\ApiResource,
  17.     ApiPlatform\Metadata\ApiProperty,
  18.     ApiPlatform\Metadata\Get,
  19.     ApiPlatform\Metadata\GetCollection,
  20.     ApiPlatform\Metadata\Post,
  21.     ApiPlatform\Metadata\Put,
  22.     ApiPlatform\Metadata\Delete,
  23.     ApiPlatform\Metadata\ApiFilter,
  24.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
  25.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
  26.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
  28. use App\Entity\Trait\IdTrait,
  29.     App\Entity\Trait\UuidTrait,
  30.     App\Entity\Trait\TimestampableTrait,
  31.     App\Entity\Trait\StatTrait,
  32.     App\Entity\Interface\SimpleEntityInterface,
  33.     App\Entity\Interface\StatableInterface,
  34.     App\Entity\Interface\PasswordResetableInterface;
  36. use App\Enum\Language,
  37.     App\Validator\Constraints\User as CustomAssert,
  38.     App\Repository\CustomerRepository,
  39.     App\StateProcessor\CustomerRegister\PostRegisterProcessor,
  40.     App\Doctrine\DBAL\Types\CustomerLoginMethodsType,
  41.     App\Enum\CustomerLoginMethod;
  43. #[ApiResource(
  44.     description: 'Customers',
  45.     normalizationContext: ['groups' => ['read', 'read:' . self::class]],
  46.     denormalizationContext: ['groups' => ['write']],
  47.     order: ['createdAt' => 'desc'],
  48.     operations: [
  49.         new GetCollection(
  50.             security: 'is_granted("' . self::class . '")'
  51.         ),
  52.         new Post(
  53.             uriTemplate: '/customers/register',
  54.             denormalizationContext: ['groups' => ['register']],
  55.             processor: PostRegisterProcessor::class,
  56.             validationContext: ['groups' => [Constraint::DEFAULT_GROUP, 'register']],
  57.         ),
  58.         new Post(
  59.             processor: PostRegisterProcessor::class,
  60.             validationContext: ['groups' => [Constraint::DEFAULT_GROUP, 'post']],
  61.         ),
  62.         new Get(
  63.             security: 'is_granted("' . self::class . '")'
  64.         ),
  65.         new Put(
  66.             security: 'is_granted("' . self::class . '")'
  67.         ),
  68.         new Delete(
  69.             security: 'is_granted("' . self::class . '")'
  70.         )
  71.     ],
  72.     extraProperties: ['standard_put' => false],
  73. )]
  74. #[ApiFilter(SearchFilter::class, properties: ['email' => 'partial', 'fullName' => 'partial'])]
  75. #[ApiFilter(BooleanFilter::class, properties: ['stat'])]
  76. #[ApiFilter(OrderFilter::class, properties: ['email', 'fullName', 'stat', 'createdAt', 'updatedAt'])]
  77. #[ORM\Entity(repositoryClass: CustomerRepository::class)]
  78. class Customer implements
  79.     SimpleEntityInterface,
  80.     StatableInterface,
  81.     UserInterface,
  82.     PasswordAuthenticatedUserInterface,
  83.     PasswordResetableInterface
  84. {
  85.     use IdTrait,
  86.         UuidTrait,
  87.         TimestampableTrait,
  88.         StatTrait;
  90.     const MAX_PREVIOUS_PASSWORDS = 5;
  92.     #[ApiProperty(description: 'Email')]
  93.     #[Groups(['read', 'write', 'register'])]
  94.     #[Assert\NotBlank]
  95.     #[Assert\Email]
  96.     #[ORM\Column(type: Types::STRING, length: 191, unique: true)]
  97.     private string $email;
  99.     #[ApiProperty(description: 'Persisted password')]
  100.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  101.     private ?string $password = null;
  103.     #[ApiProperty(description: 'New password')]
  104.     #[Groups(['write', 'register'])]
  105.     #[Assert\NotBlank(groups: ['post', 'register'])]
  106.     #[Assert\Length(max: 50, groups: [Constraint::DEFAULT_GROUP, 'profile'])]
  107.     #[Assert\Regex(
  108.         pattern: '/^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-\.]).{8,}$/',
  109.         match: true,
  110.         message: 'Password must consist of at least 8 characters (upper case, lower case, number, special character)',
  111.         groups: [Constraint::DEFAULT_GROUP, 'profile']
  112.     )]
  113.     #[Assert\NotCompromisedPassword(groups: [Constraint::DEFAULT_GROUP, 'profile'])]
  114.     #[CustomAssert\PreviousPasswords(groups: [Constraint::DEFAULT_GROUP, 'profile'])]
  115.     private ?string $rawPassword = null;
  117.     #[ApiProperty(description: 'New password repeat')]
  118.     #[Groups(['write', 'register'])]
  119.     #[Assert\Expression(
  120.         expression: 'value === this.getRawPassword()',
  121.         message: 'Passwords do not match.',
  122.         groups: ['post', 'register', 'profile']
  123.     )]
  124.     private ?string $rawPasswordRepeat = null;
  126.     #[ApiProperty(description: 'Current password')]
  127.     #[CustomAssert\CurrentPassword(groups: ['profile'])]
  128.     private ?string $currentPassword = null;
  130.     #[ApiProperty(description: 'Previous passwords')]
  131.     #[ORM\Column(type: Types::JSON)]
  132.     private array $previousPasswords = [];
  134.     #[ApiProperty(description: 'Name and surname')]
  135.     #[Groups(['read', 'write', 'register'])]
  136.     #[Assert\NotBlank]
  137.     #[Assert\Length(min: 3)]
  138.     #[ORM\Column(type: Types::STRING, length: 255)]
  139.     private string $fullName;
  141.     #[ApiProperty(description: 'Is regulations accepted')]
  142.     #[Groups(['register'])]
  143.     #[Assert\IsTrue(groups: ['register'])]
  144.     private bool $isRegulationsAccepted = false;
  146.     #[ApiProperty(description: 'Is privacy policy accepted')]
  147.     #[Groups(['register'])]
  148.     #[Assert\IsTrue(groups: ['register'])]
  149.     private bool $isPrivacyPolicyAccepted = false;
  151.     #[ApiProperty(description: 'Login methods')]
  152.     #[ORM\Column(type: CustomerLoginMethodsType::NAME)]
  153.     private array $loginMethods = [];
  155.     #[ApiProperty(description: 'Google id')]
  156.     #[Groups(['read:' . self::class])]
  157.     #[ORM\Column(type: Types::STRING, length: 1023, nullable: true)]
  158.     private ?string $googleId = null;
  160.     #[ApiProperty(description: 'Google hash')]
  161.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  162.     private ?string $googleHash = null;
  164.     #[ApiProperty(description: 'Google hash generated at')]
  165.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  166.     private ?\DateTimeImmutable $googleHashGeneratedAt = null;
  168.     #[ApiProperty(description: 'Orcid id')]
  169.     #[Groups(['read:' . self::class])]
  170.     #[ORM\Column(type: Types::STRING, length: 1023, nullable: true)]
  171.     private ?string $orcidId = null;
  173.     #[ApiProperty(description: 'Orcid hash')]
  174.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  175.     private ?string $orcidHash = null;
  177.     #[ApiProperty(description: 'Orcid hash generated at')]
  178.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  179.     private ?\DateTimeImmutable $orcidHashGeneratedAt = null;
  181.     #[ApiProperty(description: 'Register hash')]
  182.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  183.     private ?string $registerHash = null;
  185.     #[ApiProperty(description: 'Register hash generated at')]
  186.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  187.     private ?\DateTimeImmutable $registerHashGeneratedAt = null;
  189.     #[ApiProperty(description: 'Reset password hash')]
  190.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  191.     private ?string $resetPasswordHash = null;
  193.     #[ApiProperty(description: 'Reset password hash generated at')]
  194.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  195.     private ?\DateTimeImmutable $resetPasswordHashGeneratedAt = null;
  197.     #[ApiProperty(description: 'Is confirmed')]
  198.     #[Groups(['read:' . self::class])]
  199.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
  200.     private bool $isConfirmed = false;
  202.     #[ApiProperty(description: 'Register language')]
  203.     #[Groups(['read:' . self::class, 'register'])]
  204.     #[ORM\Column(
  205.         type: Types::STRING,
  206.         enumType: Language::class,
  207.         length: 255,
  208.         options: ['default' => Language::EN]
  209.     )]
  210.     private Language $registerLanguage = Language::EN;
  212.     #[ApiProperty(description: 'Last login at')]
  213.     #[Groups(['read:' . self::class])]
  214.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE)]
  215.     private \DateTimeImmutable $lastLoginAt;
  217.     #[ApiProperty(description: 'Directories')]
  218.     #[ORM\OneToMany(targetEntity: CustomerDirectory::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
  219.     #[ORM\OrderBy(['createdAt' => 'desc'])]
  220.     private Collection $directories;
  222.     private ?array $directoriesItemsUuids = null;
  224.     #[ORM\OneToMany(targetEntity: CustomerNotification::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
  225.     #[ORM\OrderBy(['createdAt' => 'desc'])]
  226.     private Collection $notifications;
  228.     public function __construct(string $email)
  229.     {
  230.         $this->setUuid();
  232.         $this->email = $email;
  234.         $this->lastLoginAt = new \DateTimeImmutable();
  236.         $this->directories = new ArrayCollection();
  237.         $this->notifications = new ArrayCollection();
  239.         $this->createdAt = new \DateTimeImmutable();
  240.         $this->updatedAt = new \DateTimeImmutable();
  241.     }
  243.     public function getEmail(): string
  244.     {
  245.         return $this->email;
  246.     }
  248.     public function getPassword(): ?string
  249.     {
  250.         return $this->password;
  251.     }
  253.     public function getRawPassword(): ?string
  254.     {
  255.         return $this->rawPassword;
  256.     }
  258.     public function setRawPassword(?string $rawPassword, UserPasswordHasherInterface $encoder): self
  259.     {
  260.         if (! $rawPassword) {
  261.             return $this;
  262.         }
  264.         $this->rawPassword = $rawPassword;
  265.         $this->password = $encoder->hashPassword($this, $rawPassword);
  267.         if (count($this->previousPasswords) >= self::MAX_PREVIOUS_PASSWORDS) {
  268.             $this->previousPasswords = array_slice($this->previousPasswords, 1);
  269.         }
  271.         $this->previousPasswords[] = password_hash($rawPassword, PASSWORD_DEFAULT);
  273.         $this->resetPasswordHash = null;
  274.         $this->resetPasswordHashGeneratedAt = null;
  276.         $this->addLoginMethod(CustomerLoginMethod::PASSWORD);
  278.         return $this;
  279.     }
  281.     public function getRawPasswordRepeat(): ?string
  282.     {
  283.         return $this->rawPasswordRepeat;
  284.     }
  286.     public function setRawPasswordRepeat(?string $rawPasswordRepeat): self
  287.     {
  288.         $this->rawPasswordRepeat = $rawPasswordRepeat;
  290.         return $this;
  291.     }
  293.     public function setHashedPassword(string $hashedPassword): self
  294.     {
  295.         $this->password = $hashedPassword;
  297.         return $this;
  298.     }
  300.     public function getCurrentPassword(): ?string
  301.     {
  302.         return $this->currentPassword;
  303.     }
  305.     public function setCurrentPassword(?string $currentPassword): self
  306.     {
  307.         $this->currentPassword = $currentPassword;
  309.         return $this;
  310.     }
  312.     public function getPreviousPasswords(): array
  313.     {
  314.         return $this->previousPasswords;
  315.     }
  317.     public function getFullName(): string
  318.     {
  319.         return $this->fullName;
  320.     }
  322.     public function setFullName(string $fullName): self
  323.     {
  324.         $this->fullName = $fullName;
  326.         return $this;
  327.     }
  329.     public function getIsRegulationsAccepted(): bool
  330.     {
  331.         return $this->isRegulationsAccepted;
  332.     }
  334.     public function setIsRegulationsAccepted(bool $isRegulationsAccepted): self
  335.     {
  336.         $this->isRegulationsAccepted = $isRegulationsAccepted;
  338.         return $this;
  339.     }
  341.     public function getIsPrivacyPolicyAccepted(): bool
  342.     {
  343.         return $this->isPrivacyPolicyAccepted;
  344.     }
  346.     public function setIsPrivacyPolicyAccepted(bool $isPrivacyPolicyAccepted): self
  347.     {
  348.         $this->isPrivacyPolicyAccepted = $isPrivacyPolicyAccepted;
  350.         return $this;
  351.     }
  353.     public function getLoginMethods(): array
  354.     {
  355.         return $this->loginMethods;
  356.     }
  358.     private function addLoginMethod(CustomerLoginMethod $method): self
  359.     {
  360.         if ($this->isLoginMethodAvailable($method)) {
  361.             return $this;
  362.         }
  364.         $this->loginMethods[] = $method;
  366.         return $this;
  367.     }
  369.     public function isLoginMethodAvailable(CustomerLoginMethod $method): bool
  370.     {
  371.         return in_array($method, $this->loginMethods);
  372.     }
  374.     public function isPasswordLoginMethodAvailable(): bool
  375.     {
  376.         return in_array(CustomerLoginMethod::PASSWORD, $this->loginMethods);
  377.     }
  379.     public function getGoogleId(): ?string
  380.     {
  381.         return $this->googleId;
  382.     }
  384.     public function setGoogleId(string $googleId): self
  385.     {
  386.         $this->googleId = $googleId;
  388.         return $this;
  389.     }
  391.     public function setGoogleHash(string $googleHash): self
  392.     {
  393.         $this->googleHash = $googleHash;
  394.         $this->googleHashGeneratedAt = new \DateTimeImmutable();
  396.         return $this;
  397.     }
  399.     public function getGoogleHash(): ?string
  400.     {
  401.         return $this->googleHash;
  402.     }
  404.     public function getGoogleHashGeneratedAt(): ?\DateTimeImmutable
  405.     {
  406.         return $this->googleHashGeneratedAt;
  407.     }
  409.     public function addGoogleLogin(): self
  410.     {
  411.         if ($this->isLoginMethodAvailable(CustomerLoginMethod::GOOGLE)) {
  412.             return $this;
  413.         }
  415.         $this->addLoginMethod(CustomerLoginMethod::GOOGLE);
  417.         $this->googleHash = null;
  418.         $this->googleHashGeneratedAt = null;
  420.         return $this;
  421.     }
  423.     public function getOrcidId(): ?string
  424.     {
  425.         return $this->orcidId;
  426.     }
  428.     public function setOrcidId(string $orcidId): self
  429.     {
  430.         $this->orcidId = $orcidId;
  432.         return $this;
  433.     }
  435.     public function setOrcidHash(string $orcidHash): self
  436.     {
  437.         $this->orcidHash = $orcidHash;
  438.         $this->orcidHashGeneratedAt = new \DateTimeImmutable();
  440.         return $this;
  441.     }
  443.     public function getOrcidHash(): ?string
  444.     {
  445.         return $this->orcidHash;
  446.     }
  448.     public function getOrcidHashGeneratedAt(): ?\DateTimeImmutable
  449.     {
  450.         return $this->orcidHashGeneratedAt;
  451.     }
  453.     public function addOrcidLogin(): self
  454.     {
  455.         if ($this->isLoginMethodAvailable(CustomerLoginMethod::ORCID)) {
  456.             return $this;
  457.         }
  459.         $this->addLoginMethod(CustomerLoginMethod::ORCID);
  461.         $this->orcidHash = null;
  462.         $this->orcidHashGeneratedAt = null;
  464.         return $this;
  465.     }
  467.     public function setRegisterHash(string $registerHash): self
  468.     {
  469.         $this->registerHash = $registerHash;
  470.         $this->registerHashGeneratedAt = new \DateTimeImmutable();
  472.         return $this;
  473.     }
  475.     public function getRegisterHash(): ?string
  476.     {
  477.         return $this->registerHash;
  478.     }
  480.     public function getRegisterHashGeneratedAt(): ?\DateTimeImmutable
  481.     {
  482.         return $this->registerHashGeneratedAt;
  483.     }
  485.     public function setResetPasswordHash(string $hash): self
  486.     {
  487.         $this->resetPasswordHash = $hash;
  488.         $this->resetPasswordHashGeneratedAt = new \DateTimeImmutable();
  490.         return $this;
  491.     }
  493.     public function getResetPasswordHash(): ?string
  494.     {
  495.         return $this->resetPasswordHash;
  496.     }
  498.     public function getResetPasswordHashGeneratedAt(): ?\DateTimeImmutable
  499.     {
  500.         return $this->resetPasswordHashGeneratedAt;
  501.     }
  503.     public function getIsConfirmed(): bool
  504.     {
  505.         return $this->isConfirmed;
  506.     }
  508.     public function confirmRegister(): self
  509.     {
  510.         if ($this->isConfirmed) {
  511.             return $this;
  512.         }
  514.         $this->isConfirmed = true;
  515.         $this->stat = true;
  517.         $this->registerHash = null;
  518.         $this->registerHashGeneratedAt = null;
  520.         return $this;
  521.     }
  523.     public function getRegisterLanguage(): Language
  524.     {
  525.         return $this->registerLanguage;
  526.     }
  528.     public function setRegisterLanguage(Language $registerLanguage): self
  529.     {
  530.         $this->registerLanguage = $registerLanguage;
  532.         return $this;
  533.     }
  535.     public function getLastLoginAt(): \DateTimeImmutable
  536.     {
  537.         return $this->lastLoginAt;
  538.     }
  540.     public function setLastLoginAt(\DateTimeImmutable $lastLoginAt): self
  541.     {
  542.         $this->lastLoginAt = $lastLoginAt;
  544.         return $this;
  545.     }
  547.     /**
  548.      * @return Collection|CustomerDirectory[]
  549.      */
  550.     public function getDirectories(): Collection
  551.     {
  552.         return $this->directories;
  553.     }
  555.     public function addDirectory(CustomerDirectory $directory): self
  556.     {
  557.         if ($this->directories->contains($directory)) {
  558.             return $this;
  559.         }
  561.         $this->directories[] = $directory;
  563.         return $this;
  564.     }
  566.     public function removeDirectory(CustomerDirectory $directory): self
  567.     {
  568.         $this->directories->removeElement($directory);
  570.         return $this;
  571.     }
  573.     /**
  574.      * @return Collection|CustomerNotification[]
  575.      */
  576.     public function getNotifications(): Collection
  577.     {
  578.         return $this->notifications;
  579.     }
  581.     public function addNotification(CustomerNotification $notification): self
  582.     {
  583.         if ($this->notifications->contains($notification)) {
  584.             return $this;
  585.         }
  587.         $this->notifications[] = $notification;
  589.         return $this;
  590.     }
  592.     public function removeNotification(CustomerNotification $notification): self
  593.     {
  594.         $this->notifications->removeElement($notification);
  596.         return $this;
  597.     }
  599.     public function getDirectoriesItemsUuids(): array
  600.     {
  601.         if (! $this->directoriesItemsUuids) {
  602.             $this->directoriesItemsUuids = [];
  604.             /** @var CustomerDirectory $directory */
  605.             foreach ($this->getDirectories() as $directory) {
  606.                 /** @var CustomerDirectoryItem $item */
  607.                 foreach ($directory->getItems() as $item) {
  608.                     $this->directoriesItemsUuids[] = $item->getVolume()?->getUuid();
  609.                     $this->directoriesItemsUuids[] = $item->getIssue()?->getUuid();
  610.                     $this->directoriesItemsUuids[] = $item->getArticle()?->getUuid();
  611.                 }
  612.             }
  613.         }
  615.         return $this->directoriesItemsUuids;
  616.     }
  618.     public function getUsername(): string
  619.     {
  620.         return $this->email;
  621.     }
  623.     public function getUserIdentifier(): string
  624.     {
  625.         return $this->email;
  626.     }
  628.     public function getRoles(): array
  629.     {
  630.         return ['ROLE_CUSTOMER'];
  631.     }
  633.     public function getSalt(): ?string
  634.     {
  635.         return null;
  636.     }
  638.     public function eraseCredentials(): void
  639.     {
  640.         return;
  641.     }
  642. }