src/Entity/User.php line 46

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Controller\ApiUserController;
  7. use App\Repository\UserRepository;
  8. use App\Entity\GroupMatchSchedule;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\DBAL\Types\Types;
  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\Serializer\Annotation\Groups;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. #[ApiResource(
  20.     normalizationContext: [
  21.         'groups' => ['read:user:collection']
  22.     ],
  23.     denormalizationContext: [
  24.         'groups' => ['write:user:admin']
  25.     ],
  26.     collectionOperations: [
  27.         'get',
  28.         'post' => [
  29.             'security' => "is_granted('ROLE_ADMIN')",
  30.             'security_message' => 'Seul un administrateur peut créer un utilisateur via l’API.',
  31.         ],
  32.         'current_user_infos' => [
  33.             'method' => 'GET',
  34.             'path' => '/users/me',
  35.             'controller' => ApiUserController::class,
  36.         ],
  37.     ],
  38.     itemOperations: [
  39.         'get',
  40.     ]
  41. )]
  42. #[ORM\Entity(repositoryClass: UserRepository::class)]
  43. #[ORM\Table(name: '`user`')]
  44. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  45. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  46. class User implements UserInterface, PasswordAuthenticatedUserInterface
  47. {
  48.     private const AVAILABILITY_SLOTS = ['now', 'tonight', 'weekend'];
  50.     #[ORM\Id]
  51.     #[ORM\GeneratedValue]
  52.     #[ORM\Column(type: 'integer')]
  53.     #[Groups([
  54.         'read:user:collection',
  55.         'read:message:collection',
  56.         'read:relation:collection',
  57.         'read:notification:collection',
  58.         'read:post:collection',
  59.         'read:placeComment:collection',
  60.         'read:groupUser:collection',
  61.         'read:event:collection',
  62.         'read:reservation:collection',
  63.         'read:conversation:collection',
  64.     ])]
  65.     private $id;
  67.     #[Groups([
  68.         'read:user:collection',
  69.         'read:message:collection',
  70.         'read:post:collection',
  71.         'read:placeComment:collection',
  72.         'read:relation:collection',
  73.         'read:notification:collection',
  74.         'read:groupUser:collection',
  75.         'read:event:collection',
  76.         'read:reservation:collection',
  77.         'read:conversation:collection',
  78.         'write:user:admin',
  79.     ])]
  80.     #[Assert\Length(min: 10, max: 50)]
  81.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  82.     private $email;
  84.     #[Groups([
  85.         'read:user:collection',
  86.         'read:post:collection',
  87.         'read:message:collection',
  88.         'read:relation:collection',
  89.         'read:notification:collection',
  90.         'read:event:collection',
  91.         'read:reservation:collection',
  92.     ])]
  93.     #[ORM\Column(type: 'string', length: 500, nullable: true)]
  94.     private $image;
  96.     #[Groups([
  97.         'read:user:collection',
  98.         'read:post:collection',
  99.         'read:message:collection',
  100.         'read:relation:collection',
  101.         'read:notification:collection',
  102.         'read:event:collection',
  103.         'read:reservation:collection',
  104.     ])]
  105.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  106.     private ?string $backgroundImage = null;
  108.     #[Groups([
  109.         'read:user:collection',
  110.         'read:message:collection',
  111.         'read:post:collection',
  112.         'read:placeComment:collection',
  113.         'read:relation:collection',
  114.         'read:notification:collection',
  115.         'read:groupUser:collection',
  116.         'read:event:collection',
  117.         'read:reservation:collection',
  118.         'write:user:admin',
  119.     ])]
  120.     #[ORM\Column(type: 'string', length: 50)]
  121.     private $username;
  123.     #[ORM\Column(type: 'json')]
  124.     private $roles = [];
  126.     #[Assert\Length(min: 6, max: 50)]
  127.     #[ORM\Column(type: 'string')]
  128.     #[Groups(['write:user:admin'])]
  129.     private $password;
  131.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  132.     private ?\DateTimeImmutable $createdAt = null;
  134.     #[Groups([
  135.         'read:user:collection',
  136.         'read:message:collection',
  137.         'read:relation:collection',
  138.     ])]
  139.     #[ORM\Column(type: 'string', length: 500, nullable: true)]
  140.     private ?string $bioShort = null;
  142.     #[ORM\OneToMany(mappedBy: 'sourceUser', targetEntity: Message::class)]
  143.     private $sourceMessages;
  145.     #[ORM\ManyToMany(targetEntity: GroupUser::class, mappedBy: 'concernedUsers', cascade: ['persist', 'remove'])]
  146.     private $groupUsers;
  148.     #[ORM\OneToOne(mappedBy: 'user', targetEntity: Flux::class, cascade: ['persist', 'remove'])]
  149.     private $flux;
  151.     #[ORM\OneToMany(mappedBy: 'initialUser', targetEntity: Activity::class)]
  152.     private $sourceAtivities;
  154.     #[ORM\ManyToMany(targetEntity: Activity::class)]
  155.     private $targetActivities;
  157.     #[ORM\OneToMany(mappedBy: 'sourceUser', targetEntity: Notification::class)]
  158.     private $sourceNotifications;
  160.     #[ORM\OneToMany(mappedBy: 'targetUser', targetEntity: Notification::class)]
  161.     private $targetNotifications;
  163.     #[ORM\Column(type: 'string', length: 500, nullable: true)]
  164.     private $authToken;
  166.     #[ORM\OneToOne(targetEntity: GroupUser::class, cascade: ['persist', 'remove'])]
  167.     private $relationGroupUser;
  169.     #[ORM\Column(type: 'text', nullable: true)]
  170.     private $payData;
  172.     #[ORM\Column(nullable: true)]
  173.     private ?bool $isActif = null;
  175.     #[ORM\Column(type: 'json', nullable: true)]
  176.     private ?array $availabilitySlots = [];
  178.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  179.     private ?\DateTimeImmutable $availabilityUpdatedAt = null;
  181.     #[ORM\OneToMany(mappedBy: 'sourceUser', targetEntity: Payment::class)]
  182.     private Collection $payments;
  184.     #[ORM\Column(nullable: true)]
  185.     private ?bool $isConfirmed = null;
  187.     #[Groups([
  188.         'read:user:collection',
  189.         'read:message:collection',
  190.         'read:relation:collection',
  191.         'read:notification:collection',
  192.         'read:conversation:collection',
  193.     ])]
  194.     #[ORM\Column(type: 'json', nullable: true)]
  195.     private ?array $requirements = [];
  197.     #[Groups([
  198.         'read:user:collection',
  199.         'read:message:collection',
  200.         'read:relation:collection',
  201.         'read:notification:collection',
  202.         'read:conversation:collection',
  203.     ])]
  204.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  205.     private bool $isPremium = false;
  207.     #[ORM\Column(nullable: true)]
  208.     private ?array $position = null;
  210.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  211.     private bool $locationOptIn = false;
  213.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  214.     private ?\DateTimeImmutable $locationUpdatedAt = null;
  216.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Reservation::class, orphanRemoval: true)]
  217.     private Collection $reservations;
  219.     #[ORM\OneToOne(mappedBy: 'owner', cascade: ['persist', 'remove'])]
  220.     private ?Account $account = null;
  222.     #[ORM\OneToMany(mappedBy: 'organizer', targetEntity: GroupMatchSchedule::class)]
  223.     private Collection $groupMatchSchedules;
  225.     #[ORM\Column(type: 'float', nullable: true)]
  226.     private ?float $reliabilityScore = null;
  228.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  229.     private bool $ageVerified = false;
  231.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  232.     private bool $identityVerified = false;
  234.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  235.     private bool $incomeVerified = false;
  237.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  238.     private bool $mfaEnabled = false;
  240.     #[ORM\Column(type: 'string', length: 30, nullable: true)]
  241.     private ?string $mfaMethod = null;
  243.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  244.     private ?\DateTimeImmutable $mfaVerifiedAt = null;
  246.     public function __construct()
  247.     {
  248.         $this->roles = ['ROLE_USER'];
  249.         $this->sourceMessages = new ArrayCollection();
  250.         $this->groupUsers = new ArrayCollection();
  251.         $this->sourceAtivities = new ArrayCollection();
  252.         $this->targetActivities = new ArrayCollection();
  253.         $this->sourceNotifications = new ArrayCollection();
  254.         $this->targetNotifications = new ArrayCollection();
  255.         $this->authToken = hash_hmac('sha512', random_bytes(150), random_bytes(150), false);
  256.         $this->payments = new ArrayCollection();
  257.         $this->reservations = new ArrayCollection();
  258.         $this->createdAt = new \DateTimeImmutable();
  259.         $this->requirements = [];
  260.         $this->isPremium = false;
  261.         $this->groupMatchSchedules = new ArrayCollection();
  262.         $this->locationOptIn = false;
  263.         $this->mfaEnabled = false;
  264.     }
  266.     public function getReliabilityScore(): ?float
  267.     {
  268.         return $this->reliabilityScore;
  269.     }
  271.     public function setReliabilityScore(?float $reliabilityScore): self
  272.     {
  273.         $this->reliabilityScore = $reliabilityScore !== null ? max(0, min(100, $reliabilityScore)) : null;
  274.         return $this;
  275.     }
  277.     public function isAgeVerified(): bool
  278.     {
  279.         return $this->ageVerified;
  280.     }
  282.     public function setAgeVerified(bool $ageVerified): self
  283.     {
  284.         $this->ageVerified = $ageVerified;
  285.         return $this;
  286.     }
  288.     public function isIdentityVerified(): bool
  289.     {
  290.         return $this->identityVerified;
  291.     }
  293.     public function setIdentityVerified(bool $identityVerified): self
  294.     {
  295.         $this->identityVerified = $identityVerified;
  296.         return $this;
  297.     }
  299.     public function isIncomeVerified(): bool
  300.     {
  301.         return $this->incomeVerified;
  302.     }
  304.     public function setIncomeVerified(bool $incomeVerified): self
  305.     {
  306.         $this->incomeVerified = $incomeVerified;
  307.         return $this;
  308.     }
  310.     public function isMfaEnabled(): bool
  311.     {
  312.         return $this->mfaEnabled;
  313.     }
  315.     public function setMfaEnabled(bool $mfaEnabled): self
  316.     {
  317.         $this->mfaEnabled = $mfaEnabled;
  318.         return $this;
  319.     }
  321.     public function getMfaMethod(): ?string
  322.     {
  323.         return $this->mfaMethod;
  324.     }
  326.     public function setMfaMethod(?string $mfaMethod): self
  327.     {
  328.         $this->mfaMethod = $mfaMethod;
  329.         return $this;
  330.     }
  332.     public function getMfaVerifiedAt(): ?\DateTimeImmutable
  333.     {
  334.         return $this->mfaVerifiedAt;
  335.     }
  337.     public function setMfaVerifiedAt(?\DateTimeImmutable $mfaVerifiedAt): self
  338.     {
  339.         $this->mfaVerifiedAt = $mfaVerifiedAt;
  340.         return $this;
  341.     }
  343.     public function getId(): ?int
  344.     {
  345.         return $this->id;
  346.     }
  348.     public function getEmail(): ?string
  349.     {
  350.         return $this->email;
  351.     }
  353.     public function setEmail(string $email): self
  354.     {
  355.         $this->email = $email;
  357.         return $this;
  358.     }
  360.     /**
  361.      * @return Collection<int, GroupMatchSchedule>
  362.      */
  363.     public function getGroupMatchSchedules(): Collection
  364.     {
  365.         return $this->groupMatchSchedules;
  366.     }
  368.     public function addGroupMatchSchedule(GroupMatchSchedule $schedule): static
  369.     {
  370.         if (!$this->groupMatchSchedules->contains($schedule)) {
  371.             $this->groupMatchSchedules->add($schedule);
  372.             $schedule->setOrganizer($this);
  373.         }
  375.         return $this;
  376.     }
  378.     public function removeGroupMatchSchedule(GroupMatchSchedule $schedule): static
  379.     {
  380.         if ($this->groupMatchSchedules->removeElement($schedule)) {
  381.             if ($schedule->getOrganizer() === $this) {
  382.                 $schedule->setOrganizer(null);
  383.             }
  384.         }
  386.         return $this;
  387.     }
  389.     /**
  390.      * A visual identifier that represents this user.
  391.      *
  392.      * @see UserInterface
  393.      */
  394.     public function getUserIdentifier(): string
  395.     {
  396.         return (string) $this->username;
  397.     }
  399.     /**
  400.      * @see UserInterface
  401.      */
  402.     public function getRoles(): array
  403.     {
  404.         $roles = $this->roles;
  405.         // guarantee every user at least has ROLE_USER
  406.         $roles[] = 'ROLE_USER';
  408.         return array_unique($roles);
  409.     }
  411.     public function setRoles(array $roles): self
  412.     {
  413.         $this->roles = $roles;
  415.         return $this;
  416.     }
  418.     /**
  419.      * @see PasswordAuthenticatedUserInterface
  420.      */
  421.     public function getPassword(): string
  422.     {
  423.         return $this->password;
  424.     }
  426.     public function setPassword(string $password): self
  427.     {
  428.         $this->password = $password;
  430.         return $this;
  431.     }
  433.     public function getCreatedAt(): ?\DateTimeImmutable
  434.     {
  435.         return $this->createdAt;
  436.     }
  438.     public function getBioShort(): ?string
  439.     {
  440.         return $this->bioShort;
  441.     }
  443.     public function setBioShort(?string $bioShort): self
  444.     {
  445.         $this->bioShort = $bioShort;
  447.         return $this;
  448.     }
  450.     public function setCreatedAt(?\DateTimeImmutable $createdAt): self
  451.     {
  452.         $this->createdAt = $createdAt;
  454.         return $this;
  455.     }
  457.     /**
  458.      * Returning a salt is only needed, if you are not using a modern
  459.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  460.      *
  461.      * @see UserInterface
  462.      */
  463.     public function getSalt(): ?string
  464.     {
  465.         return null;
  466.     }
  468.     /**
  469.      * @see UserInterface
  470.      */
  471.     public function eraseCredentials()
  472.     {
  473.         // If you store any temporary, sensitive data on the user, clear it here
  474.         // $this->plainPassword = null;
  475.     }
  477.     /**
  478.      * @return Collection<int, Message>
  479.      */
  480.     public function getSourceMessages(): Collection
  481.     {
  482.         return $this->sourceMessages;
  483.     }
  485.     public function addSourceMessage(Message $sourceMessage): self
  486.     {
  487.         if (!$this->sourceMessages->contains($sourceMessage)) {
  488.             $this->sourceMessages[] = $sourceMessage;
  489.             $sourceMessage->setSourceUser($this);
  490.         }
  492.         return $this;
  493.     }
  495.     public function removeSourceMessage(Message $sourceMessage): self
  496.     {
  497.         if ($this->sourceMessages->removeElement($sourceMessage)) {
  498.             // set the owning side to null (unless already changed)
  499.             if ($sourceMessage->getSourceUser() === $this) {
  500.                 $sourceMessage->setSourceUser(null);
  501.             }
  502.         }
  504.         return $this;
  505.     }
  507.     /**
  508.      * @return Collection<int, GroupUser>
  509.      */
  510.     public function getGroupUsers(): Collection
  511.     {
  512.         return $this->groupUsers;
  513.     }
  515.     public function addGroupUser(GroupUser $groupUser): self
  516.     {
  517.         if (!$this->groupUsers->contains($groupUser)) {
  518.             $this->groupUsers[] = $groupUser;
  519.             $groupUser->addConcernedUser($this);
  520.         }
  522.         return $this;
  523.     }
  525.     public function removeGroupUser(GroupUser $groupUser): self
  526.     {
  527.         if ($this->groupUsers->removeElement($groupUser)) {
  528.             $groupUser->removeConcernedUser($this);
  529.         }
  531.         return $this;
  532.     }
  534.     public function getFlux(): ?Flux
  535.     {
  536.         return $this->flux;
  537.     }
  539.     public function setFlux(?Flux $flux): self
  540.     {
  541.         // unset the owning side of the relation if necessary
  542.         if ($flux === null && $this->flux !== null) {
  543.             $this->flux->setUser(null);
  544.         }
  546.         // set the owning side of the relation if necessary
  547.         if ($flux !== null && $flux->getUser() !== $this) {
  548.             $flux->setUser($this);
  549.         }
  551.         $this->flux = $flux;
  553.         return $this;
  554.     }
  556.     /**
  557.      * @return Collection<int, Activity>
  558.      */
  559.     public function getSourceAtivities(): Collection
  560.     {
  561.         return $this->sourceAtivities;
  562.     }
  564.     public function addSourceAtivity(Activity $sourceAtivity): self
  565.     {
  566.         if (!$this->sourceAtivities->contains($sourceAtivity)) {
  567.             $this->sourceAtivities[] = $sourceAtivity;
  568.             $sourceAtivity->setInitialUser($this);
  569.         }
  571.         return $this;
  572.     }
  574.     public function removeSourceAtivity(Activity $sourceAtivity): self
  575.     {
  576.         if ($this->sourceAtivities->removeElement($sourceAtivity)) {
  577.             // set the owning side to null (unless already changed)
  578.             if ($sourceAtivity->getInitialUser() === $this) {
  579.                 $sourceAtivity->setInitialUser(null);
  580.             }
  581.         }
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return Collection<int, Activity>
  588.      */
  589.     public function getTargetActivities(): Collection
  590.     {
  591.         return $this->targetActivities;
  592.     }
  594.     public function addTargetActivity(Activity $targetActivity): self
  595.     {
  596.         if (!$this->targetActivities->contains($targetActivity)) {
  597.             $this->targetActivities[] = $targetActivity;
  598.             // $targetActivity->addTargetUser($this);
  599.         }
  601.         return $this;
  602.     }
  604.     /** TODO : Retiser du groupeUser de l'activité (avec une requete SQL dans le Repository) */
  605.     // TODO : Retiser du groupeUser de l'activité (avec une requete SQL dans le Repository)
  606.     // public function removeTargetActivity(Activity $targetActivity): self
  607.     // {
  608.     //     if ($this->targetActivities->removeElement($targetActivity)) {
  609.     //         $targetActivity->removeTargetUser($this);
  610.     //     }
  612.     //     return $this;
  613.     // }
  615.     /**
  616.      * @return Collection<int, Notification>
  617.      */
  618.     public function getSourceNotifications(): Collection
  619.     {
  620.         return $this->sourceNotifications;
  621.     }
  623.     public function addSourceNotification(Notification $sourceNotification): self
  624.     {
  625.         if (!$this->sourceNotifications->contains($sourceNotification)) {
  626.             $this->sourceNotifications[] = $sourceNotification;
  627.             $sourceNotification->setSourceUser($this);
  628.         }
  630.         return $this;
  631.     }
  633.     public function removeSourceNotification(Notification $sourceNotification): self
  634.     {
  635.         if ($this->sourceNotifications->removeElement($sourceNotification)) {
  636.             // set the owning side to null (unless already changed)
  637.             if ($sourceNotification->getSourceUser() === $this) {
  638.                 $sourceNotification->setSourceUser(null);
  639.             }
  640.         }
  642.         return $this;
  643.     }
  645.     /**
  646.      * @return Collection<int, Notification>
  647.      */
  648.     public function getTargetNotifications(): Collection
  649.     {
  650.         return $this->targetNotifications;
  651.     }
  653.     public function addTargetNotification(Notification $targetNotification): self
  654.     {
  655.         if (!$this->targetNotifications->contains($targetNotification)) {
  656.             $this->targetNotifications[] = $targetNotification;
  657.             $targetNotification->setTargetUser($this);
  658.         }
  660.         return $this;
  661.     }
  663.     public function removeTargetNotification(Notification $targetNotification): self
  664.     {
  665.         if ($this->targetNotifications->removeElement($targetNotification)) {
  666.             // set the owning side to null (unless already changed)
  667.             if ($targetNotification->getTargetUser() === $this) {
  668.                 $targetNotification->setTargetUser(null);
  669.             }
  670.         }
  672.         return $this;
  673.     }
  675.     public function getAuthToken(): ?string
  676.     {
  677.         return $this->authToken;
  678.     }
  680.     public function setAuthToken(?string $authToken): self
  681.     {
  682.         $this->authToken = $authToken;
  684.         return $this;
  685.     }
  687.     public function getImage(): ?string
  688.     {
  689.         return $this->image;
  690.     }
  692.     public function setImage(?string $image): self
  693.     {
  694.         $this->image = $image;
  696.         return $this;
  697.     }
  699.     public function getRelationGroupUser(): ?GroupUser
  700.     {
  701.         return $this->relationGroupUser;
  702.     }
  704.     public function setRelationGroupUser(?GroupUser $relationGroupUser): self
  705.     {
  706.         $this->relationGroupUser = $relationGroupUser;
  708.         return $this;
  709.     }
  711.     public function getUsername(): string
  712.     {
  713.         return $this->username;
  714.     }
  716.     public function setUsername(string $username): self
  717.     {
  718.         $this->username = $username;
  720.         return $this;
  721.     }
  723.     public function getPayData(): ?string
  724.     {
  725.         return $this->payData;
  726.     }
  728.     public function setPayData(?string $payData): self
  729.     {
  730.         $this->payData = $payData;
  732.         return $this;
  733.     }
  735.     public function isIsActif(): ?bool
  736.     {
  737.         return $this->isActif;
  738.     }
  740.     public function setIsActif(?bool $isActif): static
  741.     {
  742.         $this->isActif = $isActif;
  744.         return $this;
  745.     }
  747.     /**
  748.      * @return array<int, string>
  749.      */
  750.     public function getAvailabilitySlots(): array
  751.     {
  752.         return $this->normalizeAvailabilitySlots($this->availabilitySlots ?? []);
  753.     }
  755.     /**
  756.      * @param array<int, string> $availabilitySlots
  757.      */
  758.     public function setAvailabilitySlots(array $availabilitySlots): self
  759.     {
  760.         $this->availabilitySlots = $this->normalizeAvailabilitySlots($availabilitySlots);
  761.         $this->availabilityUpdatedAt = new \DateTimeImmutable();
  763.         return $this;
  764.     }
  766.     public function getAvailabilityUpdatedAt(): ?\DateTimeImmutable
  767.     {
  768.         return $this->availabilityUpdatedAt;
  769.     }
  771.     /**
  772.      * @param array<int, string> $slots
  773.      * @return array<int, string>
  774.      */
  775.     private function normalizeAvailabilitySlots(array $slots): array
  776.     {
  777.         $normalized = [];
  778.         foreach ($slots as $slot) {
  779.             $value = mb_strtolower(trim((string) $slot));
  780.             if ($value !== '' && in_array($value, self::AVAILABILITY_SLOTS, true)) {
  781.                 $normalized[] = $value;
  782.             }
  783.         }
  784.         $normalized = array_values(array_unique($normalized));
  785.         if (empty($normalized)) {
  786.             return [];
  787.         }
  788.         $order = array_flip(self::AVAILABILITY_SLOTS);
  789.         usort($normalized, static fn (string $left, string $right): int => $order[$left] <=> $order[$right]);
  791.         return $normalized;
  792.     }
  794.     /**
  795.      * @return Collection<int, Payment>
  796.      */
  797.     public function getPayments(): Collection
  798.     {
  799.         return $this->payments;
  800.     }
  802.     public function addPayment(Payment $payment): static
  803.     {
  804.         if (!$this->payments->contains($payment)) {
  805.             $this->payments->add($payment);
  806.             $payment->setSourceUser($this);
  807.         }
  809.         return $this;
  810.     }
  812.     public function removePayment(Payment $payment): static
  813.     {
  814.         if ($this->payments->removeElement($payment)) {
  815.             // set the owning side to null (unless already changed)
  816.             if ($payment->getSourceUser() === $this) {
  817.                 $payment->setSourceUser(null);
  818.             }
  819.         }
  821.         return $this;
  822.     }
  824.     public function isIsConfirmed(): ?bool
  825.     {
  826.         return $this->isConfirmed;
  827.     }
  829.     public function setIsConfirmed(?bool $isConfirmed): static
  830.     {
  831.         $this->isConfirmed = $isConfirmed;
  833.         return $this;
  834.     }
  836.     public function getPosition(): ?array
  837.     {
  838.         return $this->position;
  839.     }
  841.     public function setPosition(?array $position): static
  842.     {
  843.         $this->position = $position;
  845.         return $this;
  846.     }
  848.     public function isLocationOptIn(): bool
  849.     {
  850.         return $this->locationOptIn;
  851.     }
  853.     public function setLocationOptIn(bool $locationOptIn): self
  854.     {
  855.         $this->locationOptIn = $locationOptIn;
  856.         return $this;
  857.     }
  859.     public function getLocationUpdatedAt(): ?\DateTimeImmutable
  860.     {
  861.         return $this->locationUpdatedAt;
  862.     }
  864.     public function setLocationUpdatedAt(?\DateTimeImmutable $locationUpdatedAt): self
  865.     {
  866.         $this->locationUpdatedAt = $locationUpdatedAt;
  867.         return $this;
  868.     }
  870.     public function getRequirements(): array
  871.     {
  872.         return $this->requirements ?? [];
  873.     }
  875.     public function setRequirements(?array $requirements): static
  876.     {
  877.         $this->requirements = $requirements ?? [];
  879.         return $this;
  880.     }
  882.     public function isPremium(): bool
  883.     {
  884.         return (bool) $this->isPremium;
  885.     }
  887.     public function setIsPremium(bool $isPremium): static
  888.     {
  889.         $this->isPremium = $isPremium;
  891.         return $this;
  892.     }
  894.     /**
  895.      * @return Collection<int, Reservation>
  896.      */
  897.     public function getReservations(): Collection
  898.     {
  899.         return $this->reservations;
  900.     }
  902.     public function addReservation(Reservation $reservation): static
  903.     {
  904.         if (!$this->reservations->contains($reservation)) {
  905.             $this->reservations->add($reservation);
  906.             $reservation->setUser($this);
  907.         }
  909.         return $this;
  910.     }
  912.     public function removeReservation(Reservation $reservation): static
  913.     {
  914.         if ($this->reservations->removeElement($reservation)) {
  915.             // set the owning side to null (unless already changed)
  916.             if ($reservation->getUser() === $this) {
  917.                 $reservation->setUser(null);
  918.             }
  919.         }
  921.         return $this;
  922.     }
  924.     public function getBackgroundImage(): ?string
  925.     {
  926.         return $this->backgroundImage;
  927.     }
  929.     public function setBackgroundImage(?string $backgroundImage): static
  930.     {
  931.         $this->backgroundImage = $backgroundImage;
  933.         return $this;
  934.     }
  936.     public function getAccount(): ?Account
  937.     {
  938.         return $this->account;
  939.     }
  941.     public function setAccount(?Account $account): static
  942.     {
  943.         // unset the owning side of the relation if necessary
  944.         if ($account === null && $this->account !== null) {
  945.             $this->account->setOwner(null);
  946.         }
  948.         // set the owning side of the relation if necessary
  949.         if ($account !== null && $account->getOwner() !== $this) {
  950.             $account->setOwner($this);
  951.         }
  953.         $this->account = $account;
  955.         return $this;
  956.     }
  957. }