src/Entity/User.php line 45

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity;
  7. use App\Contracts\User\Status;
  8. use App\Contracts\User\UserInterface;
  9. use DateTime;
  10. use DateTimeImmutable;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping\Column;
  14. use Doctrine\ORM\Mapping\DiscriminatorColumn;
  15. use Doctrine\ORM\Mapping\DiscriminatorMap;
  16. use Doctrine\ORM\Mapping\Entity;
  17. use Doctrine\ORM\Mapping\GeneratedValue;
  18. use Doctrine\ORM\Mapping\HasLifecycleCallbacks;
  19. use Doctrine\ORM\Mapping\Id;
  20. use Doctrine\ORM\Mapping\Index;
  21. use Doctrine\ORM\Mapping\InheritanceType;
  22. use Doctrine\ORM\Mapping\OneToMany;
  23. use Doctrine\ORM\Mapping\OneToOne;
  24. use Doctrine\ORM\Mapping\PrePersist;
  25. use Doctrine\ORM\Mapping\PreUpdate;
  26. use Doctrine\ORM\Mapping\UniqueConstraint;
  27. use LogicException;
  28. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  29. use Symfony\Component\Security\Core\User\EquatableInterface;
  30. use Symfony\Component\Security\Core\User\UserInterface as SymfonyUserInterface;
  32. #[Entity]
  33. #[Index(columns: ['language'], name: 'idx_user_language')]
  34. #[UniqueConstraint('unique_email', ['email'])]
  35. #[UniqueEntity('email', 'Email is already used')]
  36. #[HasLifecycleCallbacks]
  37. #[InheritanceType('JOINED')]
  38. #[DiscriminatorColumn(name: 'role', type: 'string')]
  39. #[DiscriminatorMap([
  40.     Administrator::ROLE_NAME => Administrator::class,
  41.     Creator::ROLE_NAME => Creator::class,
  42.     Sponsor::ROLE_NAME => Sponsor::class,
  43.     Manager::ROLE_NAME => Manager::class,
  44. ])]
  45. class User implements UserInterface, EquatableInterface
  46. {
  47.     public const ROLE_NAME = null;
  48.     public const SOFT_DELETE_DAYS = 30;
  50.     /** @var string */
  51.     public const BIRTHDAY_FORMAT = 'm/d/Y';
  52.     /** @var string */
  53.     private const AVATAR_FILE_NAME_TEMPLATE = 'user.%d.avatar';
  55.     #[Id]
  56.     #[GeneratedValue]
  57.     #[Column(type: 'bigint', options: ['unsigned' => true])]
  58.     private ?int $id = null;
  60.     #[Column(name: 'status', type: 'smallint')]
  61.     private int $status = Status::CREATED;
  63.     #[Column(name: 'email', type: 'string', nullable: true)]
  64.     private ?string $email = null;
  66.     #[Column(name: 'phone_number', type: 'bigint', nullable: true, options: ['unsigned' => true])]
  67.     private ?int $phoneNumber = null;
  69.     #[Column(name: 'first_name', type: 'string', nullable: true)]
  70.     private ?string $firstName = null;
  72.     #[Column(name: 'last_name', type: 'string', nullable: true)]
  73.     private ?string $lastName = null;
  75.     /**
  76.      * Primary posting language as an ISO-639-1 code (e.g. 'en', 'es', 'pt'), derived from the mode of
  77.      * the creator's recent post textLanguage (profile language fallback). Stored on the profile's user
  78.      * row (creator.id === user.id). Per-profile only — not shared across owning-account peers.
  79.      */
  80.     #[Column(type: 'string', length: 8, nullable: true)]
  81.     private ?string $language = null;
  83.     #[Column(type: 'datetime', nullable: true)]
  84.     private ?DateTime $blockedUntil;
  86.     #[Column(type: 'datetime', nullable: false)]
  87.     private DateTime $createdAt;
  89.     #[Column(type: 'datetime', nullable: true)]
  90.     private ?DateTime $updatedAt = null;
  92.     #[Column('deleted_at', 'datetime', nullable: true)]
  93.     private ?DateTime $deletedAt = null;
  95.     #[OneToOne(mappedBy: 'user', targetEntity: UserLocationPermission::class)]
  96.     private ?UserLocationPermission $locationPermissionTelemetry = null;
  98.     #[OneToOne(mappedBy: 'user', targetEntity: PaymentBalance::class)]
  99.     private ?PaymentBalance $paymentBalance = null;
  101.     #[OneToOne(mappedBy: 'user', targetEntity: Referral::class)]
  102.     private ?Referral $referral = null;
  104.     #[OneToMany(mappedBy: 'referredBy', targetEntity: Referral::class)]
  105.     private Collection $referrals;
  107.     #[PrePersist]
  108.     public function prePersist(): void
  109.     {
  110.         $this->createdAt = new DateTime();
  111.     }
  113.     #[PreUpdate]
  114.     public function preUpdate(): void
  115.     {
  116.         $this->updatedAt = new DateTime();
  117.     }
  119.     public function getId(): ?int
  120.     {
  121.         return $this->id;
  122.     }
  124.     /**
  125.      * Security tokens serialize the user into the session on EVERY request. Serializing the
  126.      * full entity drags along any initialized Doctrine relations (Manager::campaigns ->
  127.      * activities -> creators ...): observed 16MB+ session payloads (Jun 11 2026) that
  128.      * overflowed session storage and silently signed managers out — see
  129.      * docs/signouts-approval-dropped-timeout.md. Persist an identity shell only; the
  130.      * security ContextListener reloads the full entity from the user provider on every
  131.      * request, and isEqualTo() keeps the refreshed token valid.
  132.      */
  133.     public function __serialize(): array
  134.     {
  135.         return [
  136.             'id' => $this->id,
  137.             'email' => $this->email,
  138.             'status' => $this->status,
  139.         ];
  140.     }
  142.     public function __unserialize(array $data): void
  143.     {
  144.         // Accept both the identity-shell format and the legacy full-entity format (sessions
  145.         // written before this change carry PHP's mangled "\0Class\0prop" keys for every
  146.         // property) so already-authenticated users survive the deploy without a logout.
  147.         $legacy = "\0" . self::class . "\0";
  148.         $this->id = $data['id'] ?? $data[$legacy . 'id'] ?? null;
  149.         $this->email = $data['email'] ?? $data[$legacy . 'email'] ?? null;
  150.         $this->status = $data['status'] ?? $data[$legacy . 'status'] ?? Status::CREATED;
  151.     }
  153.     /**
  154.      * Used by the security layer after refreshing the user from the provider. Identity (same
  155.      * concrete class + id) is sufficient — and required: the serialized shell intentionally
  156.      * carries no password (subclass typed $password properties are uninitialized on it), so
  157.      * Symfony's default password/salt comparison must never run.
  158.      */
  159.     public function isEqualTo(SymfonyUserInterface $user): bool
  160.     {
  161.         return $user instanceof static
  162.             && $this->getId() !== null
  163.             && $user->getId() === $this->getId();
  164.     }
  166.     public function getUsername(): string
  167.     {
  168.         return $this->email ?? (string)$this->id;
  169.     }
  171.     public function getFullname(): string
  172.     {
  173.         $fullName = trim(sprintf('%s %s', $this->firstName, $this->lastName));
  175.         return $fullName === '' ? $this->getUsername() : $fullName;
  176.     }
  178.     public function getPassword(): string
  179.     {
  180.         return '';
  181.     }
  183.     public function getSalt()
  184.     {
  185.         return null;
  186.     }
  188.     public function getUserIdentifier(): string
  189.     {
  190.         return (string)$this->getId();
  191.     }
  193.     public function eraseCredentials()
  194.     {
  195.         // TODO: Implement eraseCredentials() method.
  196.     }
  198.     public function getRoles(): array
  199.     {
  200.         if (static::ROLE_NAME === null) {
  201.             throw new LogicException('Undefined role name.');
  202.         }
  204.         return [static::ROLE_NAME];
  205.     }
  207.     public function isFinishedRegistration(): bool
  208.     {
  209.         return $this->checkStatus(...Status::FINISHED_LIST);
  210.     }
  212.     public function isFirstOpen(): bool
  213.     {
  214.         return !$this->checkStatus(Status::FIRST_OPEN);
  215.     }
  217.     public function firstOpen(): void
  218.     {
  219.         $this->status |= Status::FIRST_OPEN;
  220.     }
  222.     public function isEmailVerified(): bool
  223.     {
  224.         return $this->checkStatus(Status::EMAIL_VERIFIED);
  225.     }
  227.     public function isPhoneVerified(): bool
  228.     {
  229.         return $this->checkStatus(Status::PHONE_VERIFIED);
  230.     }
  232.     public function verifyPhone(): static
  233.     {
  234.         $this->status |= Status::PHONE_VERIFIED;
  236.         return $this;
  237.     }
  239.     public function verifyEmail(): static
  240.     {
  241.         $this->status |= Status::EMAIL_VERIFIED;
  243.         return $this;
  244.     }
  246.     private function checkStatus(int ...$statusList): bool
  247.     {
  248.         foreach ($statusList as $status) {
  249.             if (($this->status & $status) === 0) {
  250.                 return false;
  251.             }
  252.         }
  254.         return true;
  255.     }
  257.     public function setFirstName(string $firstName): static
  258.     {
  259.         $this->firstName = $firstName;
  261.         return $this;
  262.     }
  264.     public function setLastName(string $lastName): static
  265.     {
  266.         $this->lastName = $lastName;
  268.         return $this;
  269.     }
  271.     public function name(string $firstName, string $lastName): self
  272.     {
  273.         $this->setFirstName($firstName);
  274.         $this->setLastName($lastName);
  276.         return $this;
  277.     }
  279.     public function baseInfo(string $firstName, string $lastName): self
  280.     {
  281.         $this->firstName = $firstName;
  282.         $this->lastName = $lastName;
  284.         return $this;
  285.     }
  287.     public function getFirstName(): ?string
  288.     {
  289.         return $this->firstName;
  290.     }
  292.     public function getLastName(): ?string
  293.     {
  294.         return $this->lastName;
  295.     }
  297.     /**
  298.      * @internal Doctrine-mapped field; use {@see Creator::getLanguage()} / {@see Creator::setLanguage()}.
  299.      */
  300.     protected function getLanguageValue(): ?string
  301.     {
  302.         return $this->language;
  303.     }
  305.     /**
  306.      * @internal Doctrine-mapped field; use {@see Creator::setLanguage()}.
  307.      */
  308.     protected function setLanguageValue(?string $language): static
  309.     {
  310.         $this->language = $language;
  312.         return $this;
  313.     }
  315.     public function setPhoneNumber(?string $phoneNumber): self
  316.     {
  317.         if ($phoneNumber !== null) {
  318.             $phoneNumber = (int)preg_replace('/[^\d]/', '', $phoneNumber);
  320.             if ($this->isPhoneVerified() && $this->phoneNumber !== $phoneNumber) {
  321.                 $this->status ^= Status::PHONE_VERIFIED;
  322.             }
  323.         }
  325.         $this->phoneNumber = $phoneNumber;
  327.         return $this;
  328.     }
  330.     public function getPhoneNumber(): ?string
  331.     {
  332.         if ($this->phoneNumber === null) {
  333.             return null;
  334.         }
  336.         return sprintf('+%d', preg_replace('/[^\d]/', '', (string)($this->phoneNumber ?? '')));
  337.     }
  339.     public function setEmail(?string $email): self
  340.     {
  341.         if ($email !== null && $this->isEmailVerified() && $this->email !== $email) {
  342.             $this->status ^= Status::EMAIL_VERIFIED;
  343.         }
  345.         $this->email = $email;
  347.         return $this;
  348.     }
  350.     public function getEmail(): ?string
  351.     {
  352.         return $this->email;
  353.     }
  355.     public function getAvatarFileName(): string
  356.     {
  357.         return sprintf(self::AVATAR_FILE_NAME_TEMPLATE, $this->getId());
  358.     }
  360.     public function getDeletedAt(): ?DateTime
  361.     {
  362.         return $this->deletedAt;
  363.     }
  365.     public function getBlockedUntil(): ?DateTime
  366.     {
  367.         return $this->blockedUntil;
  368.     }
  370.     public function setDeletedAt(bool $isDeleted = true): self
  371.     {
  372.         $this->deletedAt = $isDeleted ? new DateTime() : null;
  374.         return $this;
  375.     }
  377.     public function isDeleted(): bool
  378.     {
  379.         return $this->getDeletedAt() instanceof DateTime;
  380.     }
  382.     public function isSoftDeleted(): bool
  383.     {
  384.         if (!$this->isDeleted()) {
  385.             return false;
  386.         }
  388.         $now = new DateTimeImmutable();
  389.         $interval = $now->diff($this->getDeletedAt());
  391.         return $interval->days < self::SOFT_DELETE_DAYS;
  392.     }
  394.     public function block(?DateTime $blockedUntil = null): static
  395.     {
  396.         if (!$this->checkStatus(Status::BLOCKED)) {
  397.             $this->status |= Status::BLOCKED;
  398.             $this->blockedUntil = $blockedUntil;
  399.         }
  401.         return $this;
  402.     }
  404.     public function unblock(): static
  405.     {
  406.         $this->status ^= Status::BLOCKED;
  407.         $this->blockedUntil = null;
  409.         return $this;
  410.     }
  412.     public function isBlocked(): bool
  413.     {
  414.         return $this->checkStatus(Status::BLOCKED)
  415.             && ($this->blockedUntil === null || $this->blockedUntil > new DateTime());
  416.     }
  418.     public function getCreatedAt(): DateTime
  419.     {
  420.         return $this->createdAt;
  421.     }
  423.     public function getUpdatedAt(): ?DateTime
  424.     {
  425.         return $this->updatedAt;
  426.     }
  428.     public function isRole(string $role): bool
  429.     {
  430.         return in_array($role, $this->getRoles(), true);
  431.     }
  433.     public function setPaymentBalance(PaymentBalance $paymentBalance): static
  434.     {
  435.         $this->paymentBalance = $paymentBalance;
  437.         return $this;
  438.     }
  440.     public function getPaymentBalance(): ?PaymentBalance
  441.     {
  442.         return $this->paymentBalance;
  443.     }
  445.     public function getReferral(): ?Referral
  446.     {
  447.         return $this->referral;
  448.     }
  450.     public function getReferrals(): Collection
  451.     {
  452.         return $this->referrals;
  453.     }
  455.     public function getLocationPermissionTelemetry(): ?UserLocationPermission
  456.     {
  457.         return $this->locationPermissionTelemetry;
  458.     }
  460.     public function setLocationPermissionTelemetry(?UserLocationPermission $locationPermissionTelemetry): static
  461.     {
  462.         $this->locationPermissionTelemetry = $locationPermissionTelemetry;
  464.         return $this;
  465.     }
  466. }