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;
  27. use App\Command\CustomerNotifier;
  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.     #[ORM\OneToMany(targetEntity: CustomerSentNotification::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
  229.     #[ORM\OrderBy(['createdAt' => 'desc'])]
  230.     private Collection $sentNotifications;
  232.     #[ApiProperty(description: 'Delete account hash generated at')]
  233.     #[ORM\Column(type: Types::DATETIME_IMMUTABLE, nullable: true)]
  234.     private ?\DateTimeImmutable $deleteAccountHashGeneratedAt = null;
  236.     #[ApiProperty(description: 'Delete account hash')]
  237.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  238.     private ?string $deleteAccountHash = null;
  240.     public function __construct(string $email)
  241.     {
  242.         $this->setUuid();
  244.         $this->email = $email;
  246.         $this->lastLoginAt = new \DateTimeImmutable();
  248.         $this->directories = new ArrayCollection();
  249.         $this->notifications = new ArrayCollection();
  250.         $this->sentNotifications = new ArrayCollection();
  252.         $this->createdAt = new \DateTimeImmutable();
  253.         $this->updatedAt = new \DateTimeImmutable();
  254.     }
  256.     public function getEmail(): string
  257.     {
  258.         return $this->email;
  259.     }
  261.     public function getPassword(): ?string
  262.     {
  263.         return $this->password;
  264.     }
  266.     public function getRawPassword(): ?string
  267.     {
  268.         return $this->rawPassword;
  269.     }
  271.     public function setRawPassword(?string $rawPassword, UserPasswordHasherInterface $encoder): self
  272.     {
  273.         if (! $rawPassword) {
  274.             return $this;
  275.         }
  277.         $this->rawPassword = $rawPassword;
  278.         $this->password = $encoder->hashPassword($this, $rawPassword);
  280.         if (count($this->previousPasswords) >= self::MAX_PREVIOUS_PASSWORDS) {
  281.             $this->previousPasswords = array_slice($this->previousPasswords, 1);
  282.         }
  284.         $this->previousPasswords[] = password_hash($rawPassword, PASSWORD_DEFAULT);
  286.         $this->resetPasswordHash = null;
  287.         $this->resetPasswordHashGeneratedAt = null;
  289.         $this->addLoginMethod(CustomerLoginMethod::PASSWORD);
  291.         return $this;
  292.     }
  294.     public function getRawPasswordRepeat(): ?string
  295.     {
  296.         return $this->rawPasswordRepeat;
  297.     }
  299.     public function setRawPasswordRepeat(?string $rawPasswordRepeat): self
  300.     {
  301.         $this->rawPasswordRepeat = $rawPasswordRepeat;
  303.         return $this;
  304.     }
  306.     public function setHashedPassword(string $hashedPassword): self
  307.     {
  308.         $this->password = $hashedPassword;
  310.         return $this;
  311.     }
  313.     public function getCurrentPassword(): ?string
  314.     {
  315.         return $this->currentPassword;
  316.     }
  318.     public function setCurrentPassword(?string $currentPassword): self
  319.     {
  320.         $this->currentPassword = $currentPassword;
  322.         return $this;
  323.     }
  325.     public function getPreviousPasswords(): array
  326.     {
  327.         return $this->previousPasswords;
  328.     }
  330.     public function getFullName(): string
  331.     {
  332.         return $this->fullName;
  333.     }
  335.     public function setFullName(string $fullName): self
  336.     {
  337.         $this->fullName = $fullName;
  339.         return $this;
  340.     }
  342.     public function getIsRegulationsAccepted(): bool
  343.     {
  344.         return $this->isRegulationsAccepted;
  345.     }
  347.     public function setIsRegulationsAccepted(bool $isRegulationsAccepted): self
  348.     {
  349.         $this->isRegulationsAccepted = $isRegulationsAccepted;
  351.         return $this;
  352.     }
  354.     public function getIsPrivacyPolicyAccepted(): bool
  355.     {
  356.         return $this->isPrivacyPolicyAccepted;
  357.     }
  359.     public function setIsPrivacyPolicyAccepted(bool $isPrivacyPolicyAccepted): self
  360.     {
  361.         $this->isPrivacyPolicyAccepted = $isPrivacyPolicyAccepted;
  363.         return $this;
  364.     }
  366.     public function getLoginMethods(): array
  367.     {
  368.         return $this->loginMethods;
  369.     }
  371.     private function addLoginMethod(CustomerLoginMethod $method): self
  372.     {
  373.         if ($this->isLoginMethodAvailable($method)) {
  374.             return $this;
  375.         }
  377.         $this->loginMethods[] = $method;
  379.         return $this;
  380.     }
  382.     public function isLoginMethodAvailable(CustomerLoginMethod $method): bool
  383.     {
  384.         return in_array($method, $this->loginMethods);
  385.     }
  387.     public function isPasswordLoginMethodAvailable(): bool
  388.     {
  389.         return in_array(CustomerLoginMethod::PASSWORD, $this->loginMethods);
  390.     }
  392.     public function getGoogleId(): ?string
  393.     {
  394.         return $this->googleId;
  395.     }
  397.     public function setGoogleId(string $googleId): self
  398.     {
  399.         $this->googleId = $googleId;
  401.         return $this;
  402.     }
  404.     public function setGoogleHash(string $googleHash): self
  405.     {
  406.         $this->googleHash = $googleHash;
  407.         $this->googleHashGeneratedAt = new \DateTimeImmutable();
  409.         return $this;
  410.     }
  412.     public function getGoogleHash(): ?string
  413.     {
  414.         return $this->googleHash;
  415.     }
  417.     public function getGoogleHashGeneratedAt(): ?\DateTimeImmutable
  418.     {
  419.         return $this->googleHashGeneratedAt;
  420.     }
  422.     public function addGoogleLogin(): self
  423.     {
  424.         if ($this->isLoginMethodAvailable(CustomerLoginMethod::GOOGLE)) {
  425.             return $this;
  426.         }
  428.         $this->addLoginMethod(CustomerLoginMethod::GOOGLE);
  430.         $this->googleHash = null;
  431.         $this->googleHashGeneratedAt = null;
  433.         return $this;
  434.     }
  436.     public function getOrcidId(): ?string
  437.     {
  438.         return $this->orcidId;
  439.     }
  441.     public function setOrcidId(string $orcidId): self
  442.     {
  443.         $this->orcidId = $orcidId;
  445.         return $this;
  446.     }
  448.     public function setOrcidHash(string $orcidHash): self
  449.     {
  450.         $this->orcidHash = $orcidHash;
  451.         $this->orcidHashGeneratedAt = new \DateTimeImmutable();
  453.         return $this;
  454.     }
  456.     public function getOrcidHash(): ?string
  457.     {
  458.         return $this->orcidHash;
  459.     }
  461.     public function getOrcidHashGeneratedAt(): ?\DateTimeImmutable
  462.     {
  463.         return $this->orcidHashGeneratedAt;
  464.     }
  466.     public function addOrcidLogin(): self
  467.     {
  468.         if ($this->isLoginMethodAvailable(CustomerLoginMethod::ORCID)) {
  469.             return $this;
  470.         }
  472.         $this->addLoginMethod(CustomerLoginMethod::ORCID);
  474.         $this->orcidHash = null;
  475.         $this->orcidHashGeneratedAt = null;
  477.         return $this;
  478.     }
  480.     public function setRegisterHash(string $registerHash): self
  481.     {
  482.         $this->registerHash = $registerHash;
  483.         $this->registerHashGeneratedAt = new \DateTimeImmutable();
  485.         return $this;
  486.     }
  488.     public function getRegisterHash(): ?string
  489.     {
  490.         return $this->registerHash;
  491.     }
  493.     public function getRegisterHashGeneratedAt(): ?\DateTimeImmutable
  494.     {
  495.         return $this->registerHashGeneratedAt;
  496.     }
  498.     public function setResetPasswordHash(string $hash): self
  499.     {
  500.         $this->resetPasswordHash = $hash;
  501.         $this->resetPasswordHashGeneratedAt = new \DateTimeImmutable();
  503.         return $this;
  504.     }
  506.     public function getResetPasswordHash(): ?string
  507.     {
  508.         return $this->resetPasswordHash;
  509.     }
  511.     public function getResetPasswordHashGeneratedAt(): ?\DateTimeImmutable
  512.     {
  513.         return $this->resetPasswordHashGeneratedAt;
  514.     }
  516.     public function getIsConfirmed(): bool
  517.     {
  518.         return $this->isConfirmed;
  519.     }
  521.     public function confirmRegister(): self
  522.     {
  523.         if ($this->isConfirmed) {
  524.             return $this;
  525.         }
  527.         $this->isConfirmed = true;
  528.         $this->stat = true;
  530.         $this->registerHash = null;
  531.         $this->registerHashGeneratedAt = null;
  533.         return $this;
  534.     }
  536.     public function getRegisterLanguage(): Language
  537.     {
  538.         return $this->registerLanguage;
  539.     }
  541.     public function setRegisterLanguage(Language $registerLanguage): self
  542.     {
  543.         $this->registerLanguage = $registerLanguage;
  545.         return $this;
  546.     }
  548.     public function getLastLoginAt(): \DateTimeImmutable
  549.     {
  550.         return $this->lastLoginAt;
  551.     }
  553.     public function setLastLoginAt(\DateTimeImmutable $lastLoginAt): self
  554.     {
  555.         $this->lastLoginAt = $lastLoginAt;
  557.         return $this;
  558.     }
  560.     /**
  561.      * @return Collection|CustomerDirectory[]
  562.      */
  563.     public function getDirectories(): Collection
  564.     {
  565.         return $this->directories;
  566.     }
  568.     public function addDirectory(CustomerDirectory $directory): self
  569.     {
  570.         if ($this->directories->contains($directory)) {
  571.             return $this;
  572.         }
  574.         $this->directories[] = $directory;
  576.         return $this;
  577.     }
  579.     public function removeDirectory(CustomerDirectory $directory): self
  580.     {
  581.         $this->directories->removeElement($directory);
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return Collection|CustomerNotification[]
  588.      */
  589.     public function getNotifications(): Collection
  590.     {
  591.         return $this->notifications;
  592.     }
  594.     public function addNotification(CustomerNotification $notification): self
  595.     {
  596.         if ($this->notifications->contains($notification)) {
  597.             return $this;
  598.         }
  600.         $this->notifications[] = $notification;
  602.         return $this;
  603.     }
  605.     public function removeNotification(CustomerNotification $notification): self
  606.     {
  607.         $this->notifications->removeElement($notification);
  609.         return $this;
  610.     }
  612.     public function hasNotification(Journal $journal): bool
  613.     {
  614.         return null !== $this->notifications->findFirst(
  615.             fn(int $key, CustomerNotification $notification) =>
  616.                 $notification->getStat() && $notification->getJournal() === $journal
  617.         );
  618.     }
  620.     /**
  621.      * @return Collection|CustomerSentNotification[]
  622.      */
  623.     public function getSentNotifications(): Collection
  624.     {
  625.         return $this->sentNotifications;
  626.     }
  628.     public function addSentNotification(CustomerSentNotification $sentNotification): self
  629.     {
  630.         if ($this->sentNotifications->contains($sentNotification)) {
  631.             return $this;
  632.         }
  634.         $this->sentNotifications[] = $sentNotification;
  636.         return $this;
  637.     }
  639.     public function removeSentNotification(CustomerSentNotification $sentNotification): self
  640.     {
  641.         $this->sentNotifications->removeElement($sentNotification);
  643.         return $this;
  644.     }
  646.     public function getDirectoriesItemsUuids(): array
  647.     {
  648.         if (! $this->directoriesItemsUuids) {
  649.             $this->directoriesItemsUuids = [];
  651.             /** @var CustomerDirectory $directory */
  652.             foreach ($this->getDirectories() as $directory) {
  653.                 /** @var CustomerDirectoryItem $item */
  654.                 foreach ($directory->getItems() as $item) {
  655.                     $this->directoriesItemsUuids[] = $item->getVolume()?->getUuid();
  656.                     $this->directoriesItemsUuids[] = $item->getIssue()?->getUuid();
  657.                     $this->directoriesItemsUuids[] = $item->getArticle()?->getUuid();
  658.                 }
  659.             }
  660.         }
  662.         return $this->directoriesItemsUuids;
  663.     }
  665.     public function getUsername(): string
  666.     {
  667.         return $this->email;
  668.     }
  670.     public function getUserIdentifier(): string
  671.     {
  672.         return $this->email;
  673.     }
  675.     public function getRoles(): array
  676.     {
  677.         return ['ROLE_CUSTOMER'];
  678.     }
  680.     public function getSalt(): ?string
  681.     {
  682.         return null;
  683.     }
  685.     public function eraseCredentials(): void
  686.     {
  687.         return;
  688.     }
  690.     public function getDeleteAccountHashGeneratedAt(): ?\DateTimeImmutable
  691.     {
  692.         return $this->deleteAccountHashGeneratedAt;
  693.     }
  695.     public function setDeleteAccountHashGeneratedAt(?\DateTimeImmutable $deleteAccountHashGeneratedAt): self
  696.     {
  697.         $this->deleteAccountHashGeneratedAt = $deleteAccountHashGeneratedAt;
  699.         return $this;
  700.     }
  702.     public function getDeleteAccountHash(): ?string
  703.     {
  704.         return $this->deleteAccountHash;
  705.     }
  707.     public function setDeleteAccountHash(?string $deleteAccountHash): self
  708.     {
  709.         $this->deleteAccountHash = $deleteAccountHash;
  711.         return $this;
  712.     }
  713. }