src/Entity/User.php line 31

1. <?php
3. namespace App\Entity;
5. use App\Enum\AccountType;
6. use App\Enum\PaymentDataEnum;
7. use App\Enum\PaymentType;
8. use App\Enum\SubscriptionStatus;
9. use App\Helper\MetaAttributionHelper;
10. use App\Helper\PaymentDataConstants;
11. use App\Helper\SettingConstants;
12. use App\Interfaces\IBasicUser;
13. use Doctrine\Common\Collections\ArrayCollection;
14. use Doctrine\Common\Collections\Collection;
15. use Doctrine\ORM\Mapping as ORM;
16. use Knp\DoctrineBehaviors\Model\Translatable\TranslatableTrait;
17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
18. use Symfony\Component\Security\Core\User\UserInterface;
20. #[ORM\Table(name: 'user')]
21. #[ORM\Index(name: 'IX_email', columns: ['email'])]
22. #[ORM\Index(name: 'IX_opt_in_hash', columns: ['opt_in_hash'])]
23. #[ORM\Index(name: 'IX_public_profile_hash', columns: ['public_profile_hash'])]
24. #[ORM\Index(name: 'ix_nickname', columns: ['nickname'])]
25. #[ORM\Index(name: 'ix_reset_hash', columns: ['reset_hash'])]
26. #[ORM\Index(name: 'ix_referral_code', columns: ['v_referral_code'])]
27. #[ORM\Index(name: 'ix_source', columns: ['v_source'], options: ["lengths" => [255]])]
28. #[ORM\Index(name: 'ix_mention_tag', columns: ['v_mention_tag'])]
29. #[ORM\Index(name: 'ix_social_login_user_id', columns: ['v_social_login_user_id'])]
30. #[ORM\Entity(repositoryClass: 'App\Entity\Repository\UserRepository')]
31. class User implements UserInterface, PasswordAuthenticatedUserInterface, IBasicUser
32. {
33.     use TranslatableTrait;
35.     public const DEFAULT_LOCALE = 'de';
36.     // this value defines how many edits a user has to make to be asked to join the moderators
37.     public const MODERATION_TARGET = 20;
39.     #[ORM\Id]
40.     #[ORM\Column(type: 'integer')]
41.     #[ORM\GeneratedValue(strategy: 'AUTO')]
42.     private $id;
44.     #[ORM\Column(type: 'string', nullable: true)]
45.     private $email;
47.     #[ORM\Column(type: 'string', nullable: true)]
48.     private $password;
50.     #[ORM\Column(type: 'string', nullable: true)]
51.     private $salt;
53.     #[ORM\Column(type: 'string', nullable: true)]
54.     private $firstname;
56.     #[ORM\Column(type: 'string', nullable: true)]
57.     private $lastname;
59.     #[ORM\Column(type: 'string', nullable: true)]
60.     private $nickname;
62.     #[ORM\Column(type: 'string', nullable: true)]
63.     private $address_line1;
65.     #[ORM\Column(type: 'string', nullable: true)]
66.     private $address_line2;
68.     #[ORM\Column(type: 'string', nullable: true)]
69.     private $zip_code;
71.     #[ORM\Column(type: 'string', nullable: true)]
72.     private $city;
74.     #[ORM\Column(type: 'string', nullable: true)]
75.     private $country_iso;
77.     #[ORM\Column(type: 'string', nullable: true)]
78.     private $phone;
80.     #[ORM\Column(type: 'string', nullable: true)]
81.     private $mobile;
83.     #[ORM\Column(type: 'json', nullable: true)]
84.     private $profile;
86.     #[ORM\Column(type: 'datetime', nullable: false)]
87.     private $date_created;
89.     #[ORM\Column(type: 'boolean', nullable: true)]
90.     private $is_public;
92.     #[ORM\Column(type: 'string', nullable: true)]
93.     private $public_profile_hash;
95.     #[ORM\Column(type: 'integer', nullable: true)]
96.     private $login_count;
98.     #[ORM\Column(type: 'text', nullable: true)]
99.     private $about_me;
101.     #[ORM\Column(type: 'datetime', nullable: true)]
102.     private $date_last_login;
104.     #[ORM\Column(type: 'datetime', nullable: true)]
105.     private $date_disabled;
107.     #[ORM\Column(type: 'datetime', nullable: true)]
108.     private $date_opt_in_confirmed;
110.     #[ORM\Column(type: 'float', nullable: true)]
111.     private $geo_lat;
113.     #[ORM\Column(type: 'float', nullable: true)]
114.     private $geo_lon;
116.     #[ORM\Column(type: 'string', nullable: true)]
117.     private $reset_hash;
119.     #[ORM\Column(type: 'datetime', nullable: true)]
120.     private $date_reset_created;
122.     #[ORM\Column(type: 'json', nullable: true)]
123.     private $settings;
125.     #[ORM\Column(type: 'boolean', nullable: false)]
126.     private $is_active;
128.     #[ORM\Column(type: 'string', nullable: true)]
129.     private $opt_in_hash;
131.     #[ORM\Column(type: 'string', nullable: true)]
132.     private $account_type;
134.     #[ORM\Column(type: 'json', nullable: true)]
135.     private $payment_data;
137.     #[ORM\OneToMany(targetEntity: 'App\Entity\Token', mappedBy: 'user')]
138.     private $token;
140.     #[ORM\OneToMany(targetEntity: 'App\Entity\Crop', mappedBy: 'user')]
141.     private $crop;
143.     #[ORM\OneToMany(targetEntity: 'App\Entity\SupportRequest', mappedBy: 'user')]
144.     private $supportRequest;
146.     #[ORM\OneToMany(targetEntity: 'App\Entity\Emaillog', mappedBy: 'user')]
147.     private $notificationMail;
149.     #[ORM\OneToMany(targetEntity: 'App\Entity\Patch', mappedBy: 'user')]
150.     private $patch;
152.     #[ORM\OneToMany(targetEntity: 'App\Entity\Cropaction', mappedBy: 'user')]
153.     private $cropaction;
155.     #[ORM\OneToMany(targetEntity: 'App\Entity\Todo', mappedBy: 'user')]
156.     private $todo;
158.     #[ORM\OneToMany(targetEntity: 'App\Entity\Shoporder', mappedBy: 'user')]
159.     private $shoporder;
161.     #[ORM\OneToMany(targetEntity: 'App\Entity\FavoriteCrop', mappedBy: 'user')]
162.     private $favoriteCrop;
164.     #[ORM\OneToMany(targetEntity: 'App\Entity\FavoriteContent', mappedBy: 'user')]
165.     private $contentFavorite;
167.     #[ORM\OneToMany(targetEntity: 'App\Entity\Invoice', mappedBy: 'user')]
168.     private $invoice;
170.     #[ORM\OneToMany(targetEntity: 'App\Entity\Payment', mappedBy: 'user')]
171.     private $payment;
173.     #[ORM\OneToMany(targetEntity: 'App\Entity\LoginLog', mappedBy: 'user')]
174.     private $loginLog;
176.     #[ORM\OneToMany(targetEntity: 'App\Entity\VoucherRedemption', mappedBy: 'user')]
177.     private $voucherRedemption;
179.     #[ORM\OneToMany(targetEntity: 'App\Entity\Device', mappedBy: 'user')]
180.     private $device;
182.     #[ORM\OneToMany(targetEntity: 'App\Entity\Survey', mappedBy: 'user')]
183.     private $survey;
185.     #[ORM\OneToMany(targetEntity: 'App\Entity\Post', mappedBy: 'user')]
186.     private $post;
188.     #[ORM\OneToMany(targetEntity: 'App\Entity\PostComment', mappedBy: 'user')]
189.     private $postComment;
191.     #[ORM\OneToMany(targetEntity: 'App\Entity\PostBookmark', mappedBy: 'user')]
192.     private $postBookmark;
194.     #[ORM\OneToMany(targetEntity: 'App\Entity\Rating', mappedBy: 'user')]
195.     private $rating;
197.     #[ORM\OneToMany(targetEntity: 'App\Entity\Appsurvey', mappedBy: 'user')]
198.     private $appsurvey;
200.     #[ORM\OneToMany(targetEntity: 'App\Entity\PushNotification', mappedBy: 'user')]
201.     private $pushNotification;
203.     #[ORM\OneToMany(targetEntity: 'App\Entity\Image', mappedBy: 'user')]
204.     private $image;
206.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropEdit', mappedBy: 'user')]
207.     private $cropEdit;
209.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropRating', mappedBy: 'user')]
210.     private $cropRating;
212.     #[ORM\OneToMany(targetEntity: 'App\Entity\CartItem', mappedBy: 'user')]
213.     private $cartItem;
215.     #[ORM\OneToMany(targetEntity: Garden::class, mappedBy: 'user')]
216.     private $gardens;
218.     #[ORM\OneToMany(targetEntity: PostLike::class, mappedBy: 'user')]
219.     private $postLikes;
221.     #[ORM\OneToMany(targetEntity: CommentLike::class, mappedBy: 'user')]
222.     private $commentLikes;
224.     #[ORM\OneToMany(targetEntity: Notification::class, mappedBy: 'user')]
225.     private $notifications;
227.     #[ORM\OneToMany(targetEntity: Nps::class, mappedBy: 'user', orphanRemoval: true)]
228.     private $nps;
230.     #[ORM\OneToMany(targetEntity: UserConnection::class, mappedBy: 'user')]
231.     private $userConnections;
233.     #[ORM\OneToMany(targetEntity: Reminder::class, mappedBy: 'user', orphanRemoval: true)]
234.     private $reminders;
236.     private $imageDataUri;
238.     #[ORM\OneToMany(targetEntity: ProfitwellUser::class, mappedBy: 'user', orphanRemoval: true)]
239.     private $profitwellUsers;
241.     #[ORM\OneToMany(targetEntity: Template::class, mappedBy: 'created_by_user')]
242.     private $templates;
244.     #[ORM\OneToMany(targetEntity: FavoriteTemplate::class, mappedBy: 'user', orphanRemoval: true)]
245.     private $favoriteTemplates;
247.     #[ORM\OneToMany(targetEntity: TemplateUsage::class, mappedBy: 'user', orphanRemoval: true)]
248.     private $templateUsages;
250.     #[ORM\OneToMany(targetEntity: ObjectComment::class, mappedBy: 'user', orphanRemoval: true)]
251.     private $objectComments;
253.     #[ORM\OneToMany(targetEntity: PreferencesToken::class, mappedBy: 'user', orphanRemoval: true)]
254.     private $preferencesTokens;
256.     #[ORM\OneToMany(targetEntity: Usercontent::class, mappedBy: 'user', orphanRemoval: true)]
257.     private $usercontents;
259.     #[ORM\OneToMany(targetEntity: TagConnection::class, mappedBy: 'user', orphanRemoval: true)]
260.     private $tagConnections;
262.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Croplist::class, orphanRemoval: true)]
263.     private Collection $cropLists;
265.     #[ORM\Column(length: 6, nullable: true)]
266.     private ?string $locale = null;
268.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CancellationSurvey::class, orphanRemoval: true)]
269.     private Collection $cancellationSurveys;
271.     // this virtual column is indexed via an index at the top of this file; the indexed virtual column
272.     // helps to speed up lookups for users with a referral code which is used during register
273.     #[ORM\Column(type: "string",
274.         name: "v_referral_code",
275.         columnDefinition: "VARCHAR(50) AS (JSON_VALUE(settings,'$.referralCode')) VIRTUAL",
276.         insertable: false,
277.         updatable: false,
278.         nullable: true,
279.         length: 50,
280.         generated: "ALWAYS")]
281.     private ?string $v_referralCode;
283.     // this indexed virtual column helps to speed up selects to the source of users
284.     #[ORM\Column(type: "string",
285.         name: "v_source",
286.         columnDefinition: "VARCHAR(4096) AS (JSON_VALUE(settings,'$.source')) VIRTUAL",
287.         insertable: false,
288.         updatable: false,
289.         nullable: true,
290.         length: 4096,
291.         generated: "ALWAYS")]
292.     private ?string $v_source;
294.     // this indexed virtual column helps to speed up selects of users via mention tags
295.     #[ORM\Column(type: "string",
296.         name: "v_mention_tag",
297.         columnDefinition: "VARCHAR(255) AS (JSON_VALUE(settings,'$.mentionTag')) VIRTUAL",
298.         insertable: false,
299.         updatable: false,
300.         nullable: true,
301.         length: 255,
302.         generated: "ALWAYS")]
303.     private ?string $v_mentionTag;
305.     // this indexed virtual column helps to speed up selects of users via social login user id
306.     #[ORM\Column(type: "string",
307.         name: "v_social_login_user_id",
308.         columnDefinition: "VARCHAR(100) AS (JSON_VALUE(settings,'$.socialLoginUserId')) VIRTUAL",
309.         insertable: false,
310.         updatable: false,
311.         nullable: true,
312.         length: 100,
313.         generated: "ALWAYS")]
314.     private ?string $v_socialLoginUserId;
316.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ModerationNotification::class)]
317.     private Collection $moderationNotifications;
319.     #[ORM\Column(nullable: true)]
320.     private ?array $climate_settings = [];
322.     #[ORM\Column(nullable: true)]
323.     private ?array $units = [];
325.     #[ORM\OneToMany(mappedBy: 'reported_by_user_id', targetEntity: PostReport::class, orphanRemoval: true)]
326.     private Collection $postReports;
328.     public function __construct()
329.     {
330.         $this->date_created = new \DateTime();
331.         $this->is_active = false;
333.         $this->token = new ArrayCollection();
334.         $this->supportRequest = new ArrayCollection();
335.         $this->notificationMail = new ArrayCollection();
336.         $this->patch = new ArrayCollection();
337.         $this->todo = new ArrayCollection();
338.         $this->shoporder = new ArrayCollection();
339.         $this->favoriteCrop = new ArrayCollection();
340.         $this->contentFavorite = new ArrayCollection();
341.         $this->invoice = new ArrayCollection();
342.         $this->payment = new ArrayCollection();
343.         $this->crop = new ArrayCollection();
344.         $this->loginLog = new ArrayCollection();
345.         $this->voucherRedemption = new ArrayCollection();
346.         $this->device = new ArrayCollection();
347.         $this->cropaction = new ArrayCollection();
348.         $this->survey = new ArrayCollection();
349.         $this->post = new ArrayCollection();
350.         $this->postComment = new ArrayCollection();
351.         $this->postBookmark = new ArrayCollection();
352.         $this->rating = new ArrayCollection();
353.         $this->appsurvey = new ArrayCollection();
354.         $this->pushNotification = new ArrayCollection();
355.         $this->image = new ArrayCollection();
356.         $this->cropEdit = new ArrayCollection();
357.         $this->cropRating = new ArrayCollection();
358.         $this->cartItem = new ArrayCollection();
359.         $this->gardens = new ArrayCollection();
360.         $this->postLikes = new ArrayCollection();
361.         $this->commentLikes = new ArrayCollection();
362.         $this->notifications = new ArrayCollection();
363.         $this->nps = new ArrayCollection();
364.         $this->userConnections = new ArrayCollection();
365.         $this->reminders = new ArrayCollection();
366.         $this->profitwellUsers = new ArrayCollection();
367.         $this->templates = new ArrayCollection();
368.         $this->favoriteTemplates = new ArrayCollection();
369.         $this->templateUsages = new ArrayCollection();
370.         $this->objectComments = new ArrayCollection();
371.         $this->preferencesTokens = new ArrayCollection();
372.         $this->usercontents = new ArrayCollection();
373.         $this->tagConnections = new ArrayCollection();
374.         $this->cropLists = new ArrayCollection();
375.         $this->cancellationSurveys = new ArrayCollection();
376.         $this->moderationNotifications = new ArrayCollection();
377.         $this->postReports = new ArrayCollection();
378.     }
380.     public function getId(): ?int
381.     {
382.         return $this->id;
383.     }
385.     public function getEmail(): ?string
386.     {
387.         return $this->email;
388.     }
390.     public function setEmail(?string $email): self
391.     {
392.         $this->email = $email;
394.         return $this;
395.     }
397.     public function getFirstname(): ?string
398.     {
399.         return $this->firstname;
400.     }
402.     public function setFirstname(?string $firstname): self
403.     {
404.         $this->firstname = $firstname;
406.         return $this;
407.     }
409.     public function getAddressLine1(): ?string
410.     {
411.         return $this->address_line1;
412.     }
414.     public function setAddressLine1(?string $address_line1): self
415.     {
416.         $this->address_line1 = $address_line1;
418.         return $this;
419.     }
421.     public function getAddressLine2(): ?string
422.     {
423.         return $this->address_line2;
424.     }
426.     public function setAddressLine2(?string $address_line2): self
427.     {
428.         $this->address_line2 = $address_line2;
430.         return $this;
431.     }
433.     public function getZipCode(): ?string
434.     {
435.         return $this->zip_code;
436.     }
438.     public function setZipCode(?string $zip_code): self
439.     {
440.         $this->zip_code = $zip_code;
442.         return $this;
443.     }
445.     public function getCity(): ?string
446.     {
447.         return $this->city;
448.     }
450.     public function setCity(?string $city): self
451.     {
452.         $this->city = $city;
454.         return $this;
455.     }
457.     public function getCountryIso(): ?string
458.     {
459.         return $this->country_iso;
460.     }
462.     public function setCountryIso(?string $country_iso): self
463.     {
464.         $this->country_iso = $country_iso;
466.         return $this;
467.     }
469.     public function getPhone(): ?string
470.     {
471.         return $this->phone;
472.     }
474.     public function setPhone(?string $phone): self
475.     {
476.         $this->phone = $phone;
478.         return $this;
479.     }
481.     public function getMobile(): ?string
482.     {
483.         return $this->mobile;
484.     }
486.     public function setMobile(?string $mobile): self
487.     {
488.         $this->mobile = $mobile;
490.         return $this;
491.     }
494.     public function getDateCreated(): ?\DateTimeInterface
495.     {
496.         return $this->date_created;
497.     }
499.     public function setDateCreated(\DateTimeInterface $date_created): self
500.     {
501.         $this->date_created = $date_created;
503.         return $this;
504.     }
506.     public function getDateOptInConfirmed(): ?\DateTimeInterface
507.     {
508.         return $this->date_opt_in_confirmed;
509.     }
511.     public function setDateOptInConfirmed(?\DateTimeInterface $date_opt_in_confirmed): self
512.     {
513.         $this->date_opt_in_confirmed = $date_opt_in_confirmed;
515.         return $this;
516.     }
518.     public function getIsActive(): ?bool
519.     {
520.         return $this->is_active;
521.     }
523.     public function setIsActive(bool $is_active): self
524.     {
525.         $this->is_active = $is_active;
527.         return $this;
528.     }
530.     public function getPassword(): ?string
531.     {
532.         return $this->password;
533.     }
535.     public function setPassword(?string $password): self
536.     {
537.         $this->password = $password;
539.         return $this;
540.     }
542.     /**
543.      * @return Collection|Token[]
544.      */
545.     public function getToken(): Collection
546.     {
547.         return $this->token;
548.     }
550.     public function addToken(Token $token): self
551.     {
552.         if (!$this->token->contains($token)) {
553.             $this->token[] = $token;
554.             $token->setUser($this);
555.         }
557.         return $this;
558.     }
560.     public function removeToken(Token $token): self
561.     {
562.         if ($this->token->contains($token)) {
563.             $this->token->removeElement($token);
564.             // set the owning side to null (unless already changed)
565.             if ($token->getUser() === $this) {
566.                 $token->setUser(null);
567.             }
568.         }
570.         return $this;
571.     }
573.     public function getOptInHash(): ?string
574.     {
575.         return $this->opt_in_hash;
576.     }
578.     public function setOptInHash(?string $opt_in_hash): self
579.     {
580.         $this->opt_in_hash = $opt_in_hash;
582.         return $this;
583.     }
585.     public function getAccountType(): ?string
586.     {
587.         return $this->account_type;
588.     }
590.     public function setAccountType(?string $account_type): self
591.     {
592.         $this->account_type = $account_type;
593.         $now = new \DateTime();
594.         if ($account_type === AccountType::Paid->value &&
595.             $now > new \DateTime('2024-04-14 00:00:00') &&
596.             $now < new \DateTime('2025-04-22 23:59:59')) {
597.             // easter activation 2025
598.             $this->setSetting(SettingConstants::UNLOCKED_DECORATIONS,
599.                 ["easterNest", "easterBunnyFront", "easterBunnyBack"]);
600.         }
602.         return $this;
603.     }
606.     public function eraseCredentials()
607.     {
608.         // TODO: Implement eraseCredentials() method.
609.     }
611.     public function getSalt(): ?string
612.     {
613.         return $this->salt;
614.     }
616.     public function getRoles()
617.     {
618.         return ['ROLE_USER'];
619.     }
621.     public function getUsername()
622.     {
623.         return $this->getEmail();
624.     }
626.     /**
627.      * @return Collection|SupportRequest[]
628.      */
629.     public function getSupportRequest(): Collection
630.     {
631.         return $this->supportRequest;
632.     }
634.     public function addSupportRequest(SupportRequest $supportRequest): self
635.     {
636.         if (!$this->supportRequest->contains($supportRequest)) {
637.             $this->supportRequest[] = $supportRequest;
638.             $supportRequest->setUser($this);
639.         }
641.         return $this;
642.     }
644.     public function removeSupportRequest(SupportRequest $supportRequest): self
645.     {
646.         if ($this->supportRequest->contains($supportRequest)) {
647.             $this->supportRequest->removeElement($supportRequest);
648.             // set the owning side to null (unless already changed)
649.             if ($supportRequest->getUser() === $this) {
650.                 $supportRequest->setUser(null);
651.             }
652.         }
654.         return $this;
655.     }
657.     public function setSalt(?string $salt): self
658.     {
659.         $this->salt = $salt;
661.         return $this;
662.     }
664.     public function getLastname(): ?string
665.     {
666.         return $this->lastname;
667.     }
669.     public function setLastname(?string $lastname): self
670.     {
671.         $this->lastname = $lastname;
673.         return $this;
674.     }
676.     public function getNickname(): ?string
677.     {
678.         return $this->nickname;
679.     }
681.     public function setNickname(?string $nickname): self
682.     {
683.         $this->nickname = $nickname;
685.         return $this;
686.     }
688.     public function getGeoLat(): ?float
689.     {
690.         return $this->geo_lat;
691.     }
693.     public function setGeoLat(?float $geo_lat): self
694.     {
695.         $this->geo_lat = $geo_lat;
697.         return $this;
698.     }
700.     public function getGeoLon(): ?float
701.     {
702.         return $this->geo_lon;
703.     }
705.     public function setGeoLon(?float $geo_lon): self
706.     {
707.         $this->geo_lon = $geo_lon;
709.         return $this;
710.     }
712.     /**
713.      * @return Collection|Patch[]
714.      */
715.     public function getPatch(): Collection
716.     {
717.         return $this->patch;
718.     }
720.     public function addPatch(Patch $patch): self
721.     {
722.         if (!$this->patch->contains($patch)) {
723.             $this->patch[] = $patch;
724.             $patch->setUser($this);
725.         }
727.         return $this;
728.     }
730.     public function removePatch(Patch $patch): self
731.     {
732.         if ($this->patch->contains($patch)) {
733.             $this->patch->removeElement($patch);
734.             // set the owning side to null (unless already changed)
735.             if ($patch->getUser() === $this) {
736.                 $patch->setUser(null);
737.             }
738.         }
740.         return $this;
741.     }
743.     /**
744.      * @return Collection|Todo[]
745.      */
746.     public function getTodo(): Collection
747.     {
748.         return $this->todo;
749.     }
751.     public function addTodo(Todo $todo): self
752.     {
753.         if (!$this->todo->contains($todo)) {
754.             $this->todo[] = $todo;
755.             $todo->setUser($this);
756.         }
758.         return $this;
759.     }
761.     public function removeTodo(Todo $todo): self
762.     {
763.         if ($this->todo->contains($todo)) {
764.             $this->todo->removeElement($todo);
765.             // set the owning side to null (unless already changed)
766.             if ($todo->getUser() === $this) {
767.                 $todo->setUser(null);
768.             }
769.         }
771.         return $this;
772.     }
774.     /**
775.      * @return Collection|Shoporder[]
776.      */
777.     public function getShoporder(): Collection
778.     {
779.         return $this->shoporder;
780.     }
782.     public function addShoporder(Shoporder $shoporder): self
783.     {
784.         if (!$this->shoporder->contains($shoporder)) {
785.             $this->shoporder[] = $shoporder;
786.             $shoporder->setUser($this);
787.         }
789.         return $this;
790.     }
792.     public function removeShoporder(Shoporder $shoporder): self
793.     {
794.         if ($this->shoporder->contains($shoporder)) {
795.             $this->shoporder->removeElement($shoporder);
796.             // set the owning side to null (unless already changed)
797.             if ($shoporder->getUser() === $this) {
798.                 $shoporder->setUser(null);
799.             }
800.         }
802.         return $this;
803.     }
805.     public function getPaymentData()
806.     {
807.         return $this->payment_data;
808.     }
810.     public function setPaymentData($payment_data): self
811.     {
812.         $this->payment_data = $payment_data;
814.         return $this;
815.     }
817.     public function getPaymentDataField(string $field): mixed
818.     {
819.         return $this->payment_data[$field] ?? null;
820.     }
822.     public function setPaymentDataField(string $field, mixed $value): self
823.     {
824.         $allowedFields = [
825.             PaymentDataConstants::PAYPAL_FAILURE_EMAIL_SENT,
826.             PaymentDataConstants::STATE,
827.             PaymentDataConstants::VALID_UNTIL,
828.             PaymentDataConstants::TYPE,
829.             PaymentDataConstants::PADDLE_ID
830.         ];
831.         if (!in_array($field, $allowedFields)) {
832.             throw new \Exception('invalid payment data field');
833.         }
834.         if ($this->payment_data === null) {
835.             $this->payment_data = [];
836.         }
837.         $this->payment_data[$field] = $value;
838.         return $this;
839.     }
841.     /**
842.      * @return Collection|FavoriteCrop[]
843.      */
844.     public function getFavoriteCrop(): Collection
845.     {
846.         return $this->favoriteCrop;
847.     }
849.     public function addFavoriteCrop(FavoriteCrop $favoriteCrop): self
850.     {
851.         if (!$this->favoriteCrop->contains($favoriteCrop)) {
852.             $this->favoriteCrop[] = $favoriteCrop;
853.             $favoriteCrop->setUser($this);
854.         }
856.         return $this;
857.     }
859.     public function removeFavoriteCrop(FavoriteCrop $favoriteCrop): self
860.     {
861.         if ($this->favoriteCrop->contains($favoriteCrop)) {
862.             $this->favoriteCrop->removeElement($favoriteCrop);
863.             // set the owning side to null (unless already changed)
864.             if ($favoriteCrop->getUser() === $this) {
865.                 $favoriteCrop->setUser(null);
866.             }
867.         }
869.         return $this;
870.     }
872.     /**
873.      * @return Collection|FavoriteContent[]
874.      */
875.     public function getContentFavorite(): Collection
876.     {
877.         return $this->contentFavorite;
878.     }
880.     public function addContentFavorite(FavoriteContent $contentFavorite): self
881.     {
882.         if (!$this->contentFavorite->contains($contentFavorite)) {
883.             $this->contentFavorite[] = $contentFavorite;
884.             $contentFavorite->setUser($this);
885.         }
887.         return $this;
888.     }
890.     public function removeContentFavorite(FavoriteContent $contentFavorite): self
891.     {
892.         if ($this->contentFavorite->contains($contentFavorite)) {
893.             $this->contentFavorite->removeElement($contentFavorite);
894.             // set the owning side to null (unless already changed)
895.             if ($contentFavorite->getUser() === $this) {
896.                 $contentFavorite->setUser(null);
897.             }
898.         }
900.         return $this;
901.     }
903.     public function getSettings()
904.     {
905.         return $this->settings;
906.     }
908.     public function setSettings($settings): self
909.     {
910.         $this->settings = $settings;
912.         return $this;
913.     }
915.     /**
916.      * @return Collection|Emaillog[]
917.      */
918.     public function getNotificationMail(): Collection
919.     {
920.         return $this->notificationMail;
921.     }
923.     public function addNotificationMail(Emaillog $notificationMail): self
924.     {
925.         if (!$this->notificationMail->contains($notificationMail)) {
926.             $this->notificationMail[] = $notificationMail;
927.             $notificationMail->setUser($this);
928.         }
930.         return $this;
931.     }
933.     public function removeNotificationMail(Emaillog $notificationMail): self
934.     {
935.         if ($this->notificationMail->contains($notificationMail)) {
936.             $this->notificationMail->removeElement($notificationMail);
937.             // set the owning side to null (unless already changed)
938.             if ($notificationMail->getUser() === $this) {
939.                 $notificationMail->setUser(null);
940.             }
941.         }
943.         return $this;
944.     }
946.     public function getResetHash(): ?string
947.     {
948.         return $this->reset_hash;
949.     }
951.     public function setResetHash(?string $reset_hash): self
952.     {
953.         $this->reset_hash = $reset_hash;
955.         return $this;
956.     }
958.     public function getDateResetCreated(): ?\DateTimeInterface
959.     {
960.         return $this->date_reset_created;
961.     }
963.     public function setDateResetCreated(?\DateTimeInterface $date_reset_created): self
964.     {
965.         $this->date_reset_created = $date_reset_created;
967.         return $this;
968.     }
970.     public function getDateLastLogin(): ?\DateTimeInterface
971.     {
972.         return $this->date_last_login;
973.     }
975.     public function setDateLastLogin(?\DateTimeInterface $date_last_login): self
976.     {
977.         $this->date_last_login = $date_last_login;
979.         return $this;
980.     }
982.     /**
983.      * @return Collection|Invoice[]
984.      */
985.     public function getInvoice(): Collection
986.     {
987.         return $this->invoice;
988.     }
990.     public function addInvoice(Invoice $invoice): self
991.     {
992.         if (!$this->invoice->contains($invoice)) {
993.             $this->invoice[] = $invoice;
994.             $invoice->setUser($this);
995.         }
997.         return $this;
998.     }
1000.     public function removeInvoice(Invoice $invoice): self
1001.     {
1002.         if ($this->invoice->contains($invoice)) {
1003.             $this->invoice->removeElement($invoice);
1004.             // set the owning side to null (unless already changed)
1005.             if ($invoice->getUser() === $this) {
1006.                 $invoice->setUser(null);
1007.             }
1008.         }
1010.         return $this;
1011.     }
1013.     /**
1014.      * @return Collection|Payment[]
1015.      */
1016.     public function getPayment(): Collection
1017.     {
1018.         return $this->payment;
1019.     }
1021.     public function addPayment(Payment $payment): self
1022.     {
1023.         if (!$this->payment->contains($payment)) {
1024.             $this->payment[] = $payment;
1025.             $payment->setUser($this);
1026.         }
1028.         return $this;
1029.     }
1031.     public function removePayment(Payment $payment): self
1032.     {
1033.         if ($this->payment->contains($payment)) {
1034.             $this->payment->removeElement($payment);
1035.             // set the owning side to null (unless already changed)
1036.             if ($payment->getUser() === $this) {
1037.                 $payment->setUser(null);
1038.             }
1039.         }
1041.         return $this;
1042.     }
1044.     public function getIsPublic(): ?bool
1045.     {
1046.         return $this->is_public;
1047.     }
1049.     public function setIsPublic(?bool $is_public): self
1050.     {
1051.         $this->is_public = $is_public;
1053.         return $this;
1054.     }
1056.     public function getPublicProfileHash(): ?string
1057.     {
1058.         return $this->public_profile_hash;
1059.     }
1061.     public function setPublicProfileHash(?string $public_profile_hash): self
1062.     {
1063.         $this->public_profile_hash = $public_profile_hash;
1065.         return $this;
1066.     }
1068.     public function getAboutMe(): ?string
1069.     {
1070.         return $this->about_me;
1071.     }
1073.     public function setAboutMe(?string $about_me): self
1074.     {
1075.         $this->about_me = $about_me;
1077.         return $this;
1078.     }
1080.     /**
1081.      * @return Collection|Crop[]
1082.      */
1083.     public function getCrop(): Collection
1084.     {
1085.         return $this->crop;
1086.     }
1088.     public function addCrop(Crop $crop): self
1089.     {
1090.         if (!$this->crop->contains($crop)) {
1091.             $this->crop[] = $crop;
1092.             $crop->setUser($this);
1093.         }
1095.         return $this;
1096.     }
1098.     public function removeCrop(Crop $crop): self
1099.     {
1100.         if ($this->crop->contains($crop)) {
1101.             $this->crop->removeElement($crop);
1102.             // set the owning side to null (unless already changed)
1103.             if ($crop->getUser() === $this) {
1104.                 $crop->setUser(null);
1105.             }
1106.         }
1108.         return $this;
1109.     }
1111.     /**
1112.      * @return Collection|LoginLog[]
1113.      */
1114.     public function getLoginLog(): Collection
1115.     {
1116.         return $this->loginLog;
1117.     }
1119.     public function addLoginLog(LoginLog $loginLog): self
1120.     {
1121.         if (!$this->loginLog->contains($loginLog)) {
1122.             $this->loginLog[] = $loginLog;
1123.             $loginLog->setUser($this);
1124.         }
1126.         return $this;
1127.     }
1129.     public function removeLoginLog(LoginLog $loginLog): self
1130.     {
1131.         if ($this->loginLog->contains($loginLog)) {
1132.             $this->loginLog->removeElement($loginLog);
1133.             // set the owning side to null (unless already changed)
1134.             if ($loginLog->getUser() === $this) {
1135.                 $loginLog->setUser(null);
1136.             }
1137.         }
1139.         return $this;
1140.     }
1142.     /**
1143.      * @return Collection|VoucherRedemption[]
1144.      */
1145.     public function getVoucherRedemption(): Collection
1146.     {
1147.         return $this->voucherRedemption;
1148.     }
1150.     public function addVoucherRedemption(VoucherRedemption $voucherRedemption): self
1151.     {
1152.         if (!$this->voucherRedemption->contains($voucherRedemption)) {
1153.             $this->voucherRedemption[] = $voucherRedemption;
1154.             $voucherRedemption->setUser($this);
1155.         }
1157.         return $this;
1158.     }
1160.     public function removeVoucherRedemption(VoucherRedemption $voucherRedemption): self
1161.     {
1162.         if ($this->voucherRedemption->contains($voucherRedemption)) {
1163.             $this->voucherRedemption->removeElement($voucherRedemption);
1164.             // set the owning side to null (unless already changed)
1165.             if ($voucherRedemption->getUser() === $this) {
1166.                 $voucherRedemption->setUser(null);
1167.             }
1168.         }
1170.         return $this;
1171.     }
1173.     /**
1174.      * @return Collection|Device[]
1175.      */
1176.     public function getDevice(): Collection
1177.     {
1178.         return $this->device;
1179.     }
1181.     public function addDevice(Device $device): self
1182.     {
1183.         if (!$this->device->contains($device)) {
1184.             $this->device[] = $device;
1185.             $device->setUser($this);
1186.         }
1188.         return $this;
1189.     }
1191.     public function removeDevice(Device $device): self
1192.     {
1193.         if ($this->device->contains($device)) {
1194.             $this->device->removeElement($device);
1195.             // set the owning side to null (unless already changed)
1196.             if ($device->getUser() === $this) {
1197.                 $device->setUser(null);
1198.             }
1199.         }
1201.         return $this;
1202.     }
1204.     public function getDateDisabled(): ?\DateTimeInterface
1205.     {
1206.         return $this->date_disabled;
1207.     }
1209.     public function setDateDisabled(?\DateTimeInterface $date_disabled): self
1210.     {
1211.         $this->date_disabled = $date_disabled;
1213.         return $this;
1214.     }
1216.     /**
1217.      * @return Collection|Cropaction[]
1218.      */
1219.     public function getCropaction(): Collection
1220.     {
1221.         return $this->cropaction;
1222.     }
1224.     public function addCropaction(Cropaction $cropaction): self
1225.     {
1226.         if (!$this->cropaction->contains($cropaction)) {
1227.             $this->cropaction[] = $cropaction;
1228.             $cropaction->setUser($this);
1229.         }
1231.         return $this;
1232.     }
1234.     public function removeCropaction(Cropaction $cropaction): self
1235.     {
1236.         if ($this->cropaction->contains($cropaction)) {
1237.             $this->cropaction->removeElement($cropaction);
1238.             // set the owning side to null (unless already changed)
1239.             if ($cropaction->getUser() === $this) {
1240.                 $cropaction->setUser(null);
1241.             }
1242.         }
1244.         return $this;
1245.     }
1247.     /**
1248.      * @return Collection|Survey[]
1249.      */
1250.     public function getSurvey(): Collection
1251.     {
1252.         return $this->survey;
1253.     }
1255.     public function addSurvey(Survey $survey): self
1256.     {
1257.         if (!$this->survey->contains($survey)) {
1258.             $this->survey[] = $survey;
1259.             $survey->setUser($this);
1260.         }
1262.         return $this;
1263.     }
1265.     public function removeSurvey(Survey $survey): self
1266.     {
1267.         if ($this->survey->contains($survey)) {
1268.             $this->survey->removeElement($survey);
1269.             // set the owning side to null (unless already changed)
1270.             if ($survey->getUser() === $this) {
1271.                 $survey->setUser(null);
1272.             }
1273.         }
1275.         return $this;
1276.     }
1278.     /**
1279.      * @return Collection|Post[]
1280.      */
1281.     public function getPost(): Collection
1282.     {
1283.         return $this->post;
1284.     }
1286.     public function addPost(Post $post): self
1287.     {
1288.         if (!$this->post->contains($post)) {
1289.             $this->post[] = $post;
1290.             $post->setUser($this);
1291.         }
1293.         return $this;
1294.     }
1296.     public function removePost(Post $post): self
1297.     {
1298.         if ($this->post->contains($post)) {
1299.             $this->post->removeElement($post);
1300.             // set the owning side to null (unless already changed)
1301.             if ($post->getUser() === $this) {
1302.                 $post->setUser(null);
1303.             }
1304.         }
1306.         return $this;
1307.     }
1309.     /**
1310.      * @return Collection|PostComment[]
1311.      */
1312.     public function getPostComment(): Collection
1313.     {
1314.         return $this->postComment;
1315.     }
1317.     public function addPostComment(PostComment $postComment): self
1318.     {
1319.         if (!$this->postComment->contains($postComment)) {
1320.             $this->postComment[] = $postComment;
1321.             $postComment->setUser($this);
1322.         }
1324.         return $this;
1325.     }
1327.     public function removePostComment(PostComment $postComment): self
1328.     {
1329.         if ($this->postComment->contains($postComment)) {
1330.             $this->postComment->removeElement($postComment);
1331.             // set the owning side to null (unless already changed)
1332.             if ($postComment->getUser() === $this) {
1333.                 $postComment->setUser(null);
1334.             }
1335.         }
1337.         return $this;
1338.     }
1340.     /**
1341.      * @return Collection|PostBookmark[]
1342.      */
1343.     public function getPostBookmark(): Collection
1344.     {
1345.         return $this->postBookmark;
1346.     }
1348.     public function addPostBookmark(PostBookmark $postBookmark): self
1349.     {
1350.         if (!$this->postBookmark->contains($postBookmark)) {
1351.             $this->postBookmark[] = $postBookmark;
1352.             $postBookmark->setUser($this);
1353.         }
1355.         return $this;
1356.     }
1358.     public function removePostBookmark(PostBookmark $postBookmark): self
1359.     {
1360.         if ($this->postBookmark->contains($postBookmark)) {
1361.             $this->postBookmark->removeElement($postBookmark);
1362.             // set the owning side to null (unless already changed)
1363.             if ($postBookmark->getUser() === $this) {
1364.                 $postBookmark->setUser(null);
1365.             }
1366.         }
1368.         return $this;
1369.     }
1371.     /**
1372.      * @return Collection|Rating[]
1373.      */
1374.     public function getRating(): Collection
1375.     {
1376.         return $this->rating;
1377.     }
1379.     public function addRating(Rating $rating): self
1380.     {
1381.         if (!$this->rating->contains($rating)) {
1382.             $this->rating[] = $rating;
1383.             $rating->setUser($this);
1384.         }
1386.         return $this;
1387.     }
1389.     public function removeRating(Rating $rating): self
1390.     {
1391.         if ($this->rating->contains($rating)) {
1392.             $this->rating->removeElement($rating);
1393.             // set the owning side to null (unless already changed)
1394.             if ($rating->getUser() === $this) {
1395.                 $rating->setUser(null);
1396.             }
1397.         }
1399.         return $this;
1400.     }
1402.     public function getProfile($skipTranslation = false): ?array
1403.     {
1404.         $profile = $this->profile;
1405.         if (!$skipTranslation && isset($profile['descriptionTranslation']) &&
1406.             $this->getCurrentLocale() !== $this->getDefaultLocale() &&
1407.             isset($profile['descriptionTranslation'][$this->getCurrentLocale()])) {
1409.             $profile['originalDescription'] = $profile['description'];
1410.             $profile['description'] = $profile['descriptionTranslation'][$this->getCurrentLocale()];
1411.         }
1412.         return $profile;
1413.     }
1415.     public function setProfile(?array $profile): self
1416.     {
1417.         $this->profile = $profile;
1419.         return $this;
1420.     }
1422.     public function getIsProfileTranslated(): bool
1423.     {
1424.         return isset($this->profile['descriptionTranslation']) &&
1425.             $this->getCurrentLocale() !== $this->getDefaultLocale() &&
1426.             isset($this->profile['descriptionTranslation'][$this->getCurrentLocale()]);
1427.     }
1429.     /**
1430.      * @return Collection|Appsurvey[]
1431.      */
1432.     public function getAppsurvey(): Collection
1433.     {
1434.         return $this->appsurvey;
1435.     }
1437.     public function addAppsurvey(Appsurvey $appsurvey): self
1438.     {
1439.         if (!$this->appsurvey->contains($appsurvey)) {
1440.             $this->appsurvey[] = $appsurvey;
1441.             $appsurvey->setUser($this);
1442.         }
1444.         return $this;
1445.     }
1447.     public function removeAppsurvey(Appsurvey $appsurvey): self
1448.     {
1449.         if ($this->appsurvey->contains($appsurvey)) {
1450.             $this->appsurvey->removeElement($appsurvey);
1451.             // set the owning side to null (unless already changed)
1452.             if ($appsurvey->getUser() === $this) {
1453.                 $appsurvey->setUser(null);
1454.             }
1455.         }
1457.         return $this;
1458.     }
1460.     /**
1461.      * @return Collection|PushNotification[]
1462.      */
1463.     public function getPushNotification(): Collection
1464.     {
1465.         return $this->pushNotification;
1466.     }
1468.     public function addPushNotification(PushNotification $pushNotification): self
1469.     {
1470.         if (!$this->pushNotification->contains($pushNotification)) {
1471.             $this->pushNotification[] = $pushNotification;
1472.             $pushNotification->setUser($this);
1473.         }
1475.         return $this;
1476.     }
1478.     public function removePushNotification(PushNotification $pushNotification): self
1479.     {
1480.         if ($this->pushNotification->contains($pushNotification)) {
1481.             $this->pushNotification->removeElement($pushNotification);
1482.             // set the owning side to null (unless already changed)
1483.             if ($pushNotification->getUser() === $this) {
1484.                 $pushNotification->setUser(null);
1485.             }
1486.         }
1488.         return $this;
1489.     }
1491.     public function getLoginCount(): ?int
1492.     {
1493.         return $this->login_count;
1494.     }
1496.     public function setLoginCount(?int $login_count): self
1497.     {
1498.         $this->login_count = $login_count;
1500.         return $this;
1501.     }
1503.     /**
1504.      * @return Collection|Image[]
1505.      */
1506.     public function getImage(): Collection
1507.     {
1508.         return $this->image;
1509.     }
1511.     public function addImage(Image $image): self
1512.     {
1513.         if (!$this->image->contains($image)) {
1514.             $this->image[] = $image;
1515.             $image->setUser($this);
1516.         }
1518.         return $this;
1519.     }
1521.     public function removeImage(Image $image): self
1522.     {
1523.         if ($this->image->removeElement($image)) {
1524.             // set the owning side to null (unless already changed)
1525.             if ($image->getUser() === $this) {
1526.                 $image->setUser(null);
1527.             }
1528.         }
1530.         return $this;
1531.     }
1533.     /**
1534.      * @return Collection|CropEdit[]
1535.      */
1536.     public function getCropEdit(): Collection
1537.     {
1538.         return $this->cropEdit;
1539.     }
1541.     public function addCropEdit(CropEdit $cropEdit): self
1542.     {
1543.         if (!$this->cropEdit->contains($cropEdit)) {
1544.             $this->cropEdit[] = $cropEdit;
1545.             $cropEdit->setUser($this);
1546.         }
1548.         return $this;
1549.     }
1551.     public function removeCropEdit(CropEdit $cropEdit): self
1552.     {
1553.         if ($this->cropEdit->removeElement($cropEdit)) {
1554.             // set the owning side to null (unless already changed)
1555.             if ($cropEdit->getUser() === $this) {
1556.                 $cropEdit->setUser(null);
1557.             }
1558.         }
1560.         return $this;
1561.     }
1563.     /**
1564.      * @return Collection|CropRating[]
1565.      */
1566.     public function getCropRating(): Collection
1567.     {
1568.         return $this->cropRating;
1569.     }
1571.     public function addCropRating(CropRating $cropRating): self
1572.     {
1573.         if (!$this->cropRating->contains($cropRating)) {
1574.             $this->cropRating[] = $cropRating;
1575.             $cropRating->setUser($this);
1576.         }
1578.         return $this;
1579.     }
1581.     public function removeCropRating(CropRating $cropRating): self
1582.     {
1583.         if ($this->cropRating->removeElement($cropRating)) {
1584.             // set the owning side to null (unless already changed)
1585.             if ($cropRating->getUser() === $this) {
1586.                 $cropRating->setUser(null);
1587.             }
1588.         }
1590.         return $this;
1591.     }
1593.     /**
1594.      * @return Collection|CartItem[]
1595.      */
1596.     public function getCartItem(): Collection
1597.     {
1598.         return $this->cartItem;
1599.     }
1601.     public function addCartItem(CartItem $cartItem): self
1602.     {
1603.         if (!$this->cartItem->contains($cartItem)) {
1604.             $this->cartItem[] = $cartItem;
1605.             $cartItem->setUser($this);
1606.         }
1608.         return $this;
1609.     }
1611.     public function removeCartItem(CartItem $cartItem): self
1612.     {
1613.         if ($this->cartItem->removeElement($cartItem)) {
1614.             // set the owning side to null (unless already changed)
1615.             if ($cartItem->getUser() === $this) {
1616.                 $cartItem->setUser(null);
1617.             }
1618.         }
1620.         return $this;
1621.     }
1623.     /**
1624.      * @return Collection|Garden[]
1625.      */
1626.     public function getGardens(): Collection
1627.     {
1628.         return $this->gardens;
1629.     }
1631.     public function addGarden(Garden $garden): self
1632.     {
1633.         if (!$this->gardens->contains($garden)) {
1634.             $this->gardens[] = $garden;
1635.             $garden->setUser($this);
1636.         }
1638.         return $this;
1639.     }
1641.     public function removeGarden(Garden $garden): self
1642.     {
1643.         if ($this->gardens->removeElement($garden)) {
1644.             // set the owning side to null (unless already changed)
1645.             if ($garden->getUser() === $this) {
1646.                 $garden->setUser(null);
1647.             }
1648.         }
1650.         return $this;
1651.     }
1653.     public function isPaidAccount(): bool
1654.     {
1655.         $paidTypes = [
1656.             AccountType::Paid->value,
1657.             AccountType::Plus->value,
1658.             AccountType::Pro->value
1659.         ];
1660.         return in_array($this->account_type, $paidTypes);
1661.     }
1663.     public function isValidPaidAccount(): bool
1664.     {
1665.         if (!$this->isPaidAccount()) {
1666.             return false;
1667.         }
1668.         if ($this->isLifetimePayment()) {
1669.             return true;
1670.         }
1671.         $paymentData = $this->getPaymentData();
1672.         $validUntil = (new \DateTime($paymentData[PaymentDataConstants::VALID_UNTIL]))->setTime(23, 59, 59);
1673.         $today = (new \DateTime())->setTime(0, 0, 0);
1674.         return $validUntil >= $today;
1675.     }
1677.     public function isReferralActivated(): bool
1678.     {
1679.         $type = $this->getPaymentDataField(PaymentDataConstants::TYPE);
1680.         return isset($type) && $type === PaymentType::Referral->value;
1681.     }
1683.     public function isLifetimePayment(): bool
1684.     {
1685.         $type = $this->getPaymentDataField(PaymentDataConstants::TYPE);
1686.         return isset($type) && $type === PaymentType::Lifetime->value;
1687.     }
1689.     public function isSubscriptionTrialPayment(): bool
1690.     {
1691.         $trialEnd = $this->getTrialEndDate();
1692.         if ($trialEnd === null) {
1693.             return false;
1694.         }
1695.         $today = (new \DateTime())->setTime(23, 59, 59);
1697.         return $today < $trialEnd;
1698.     }
1700.     public function isInAppPayment(): bool
1701.     {
1702.         $paymentData = $this->getPaymentData();
1703.         return isset($paymentData[PaymentDataConstants::IN_APP]);
1704.     }
1706.     public function getTrialEndDate($format = false): ?\DateTime
1707.     {
1708.         if (!$this->isPaidAccount() || $this->isLifetimePayment()) {
1709.             return null;
1710.         }
1711.         $start = $this->getPaymentStartDate();
1712.         if ($start === null) {
1713.             return null;
1714.         }
1715.         return (clone $start)->modify('+7 days')->setTime(23, 59, 59);
1716.     }
1718.     public function getPaymentStartDate(): ?\DateTime
1719.     {
1720.         $start = null;
1721.         $paymentData = $this->getPaymentData();
1722.         if (isset($paymentData[PaymentDataConstants::START_DATE])) {
1723.             $start = (new \DateTime($paymentData[PaymentDataConstants::START_DATE]))->setTime(0, 0);
1724.         } elseif (isset($paymentData[PaymentDataConstants::VALID_FROM])) {
1725.             $start = (new \DateTime($paymentData[PaymentDataConstants::VALID_FROM]))->setTime(0, 0);
1726.         }
1727.         return $start;
1728.     }
1730.     public function getSubscriptionStatus(): string
1731.     {
1732.         $paymentData = $this->getPaymentData();
1733.         if (empty($paymentData) || !isset($paymentData[PaymentDataConstants::TYPE])) {
1734.             return SubscriptionStatus::None->value;
1735.         }
1736.         if ($paymentData[PaymentDataConstants::TYPE] === 'referral' ||
1737.             $paymentData[PaymentDataConstants::TYPE] === 'voucher') {
1738.             return SubscriptionStatus::None->value;
1739.         }
1740.         if (isset($paymentData[PaymentDataConstants::IN_APP])) {
1741.             // iap status can be: Active, Cancelled, Expired -> we only map to active or cancelled
1742.             // if no iap status is set, the subscription is active too
1743.             if ((!isset($paymentData[PaymentDataConstants::IAP_STATUS]) && $this->isValidPaidAccount())
1744.                 || (isset($paymentData[PaymentDataConstants::IAP_STATUS]) &&
1745.                     $paymentData[PaymentDataConstants::IAP_STATUS] === PaymentDataEnum::IapStatusActive->value)) {
1746.                 return SubscriptionStatus::Active->value;
1747.             }
1748.             return SubscriptionStatus::Cancelled->value;
1749.         } else {
1750.             if (isset($paymentData[PaymentDataConstants::STATE])) {
1751.                 if ($paymentData[PaymentDataConstants::STATE] === PaymentDataEnum::IapStatusActive->value) {
1752.                     return SubscriptionStatus::Active->value;
1753.                 }
1754.                 return SubscriptionStatus::Cancelled->value;
1755.             }
1756.         }
1757.         return SubscriptionStatus::None->value;
1758.     }
1760.     public function getSubscriptionId(): ?string
1761.     {
1762.         $paymentData = $this->getPaymentData();
1763.         if (isset($paymentData[PaymentDataConstants::AGREEMENT_ID])) {
1764.             return $paymentData[PaymentDataConstants::AGREEMENT_ID];
1765.         }
1766.         return null;
1767.     }
1769.     public function getPaddleSubscriptionId(): ?string
1770.     {
1771.         $paymentData = $this->getPaymentData();
1772.         if (isset($paymentData[PaymentDataConstants::PADDLE_ID])) {
1773.             return $paymentData[PaymentDataConstants::PADDLE_ID];
1774.         }
1775.         return null;
1776.     }
1778.     public function getSubscriptionType(): ?string
1779.     {
1780.         $paymentData = $this->getPaymentData();
1781.         $locale = $this->getLocale();
1782.         $subscriptionType = '';
1783.         if (isset($paymentData[PaymentDataConstants::TYPE])) {
1784.             if ($locale === 'en') {
1785.                 $subscriptionType = $paymentData[PaymentDataConstants::TYPE] === 'monthly' ? 'monthly subscription' : 'yearly subscription';
1786.             } else {
1787.                 $subscriptionType = $paymentData[PaymentDataConstants::TYPE] === 'monthly' ? 'Monatsabo' : 'Jahresabo';
1788.             }
1789.         }
1790.         return $subscriptionType;
1791.     }
1793.     public function getSubscriptionTypeEnum(): ?string
1794.     {
1795.         $paymentData = $this->getPaymentData();
1796.         if (isset($paymentData[PaymentDataConstants::TYPE]) &&
1797.             isset($paymentData[PaymentDataConstants::TYPE]) !== null) {
1798.             return $paymentData[PaymentDataConstants::TYPE];
1799.         }
1800.         return 'none';
1801.     }
1803.     public function getPaymentType(): ?string
1804.     {
1805.         $paymentData = $this->getPaymentData();
1806.         if ($this->getSubscriptionTypeEnum() === 'voucher') {
1807.             return 'voucher';
1808.         }
1809.         if (isset($paymentData[PaymentDataConstants::IN_APP])) {
1810.             // todo: in-app google / apple
1811.             $payments = $this->getPayment();
1812.             if ($payments->count() === 0) {
1813.                 return 'in-app';
1814.             } else {
1815.                 /** @var Payment $lastPayment */
1816.                 $lastPayment = $payments->last();
1817.                 return 'in-app-' . $lastPayment->getProvider();
1818.             }
1819.         }
1820.         if (isset($paymentData[PaymentDataConstants::AGREEMENT_ID])) {
1821.             return 'paypal';
1822.         }
1823.         return 'none';
1824.     }
1826.     public function setSetting($settingName, $settingValue): void
1827.     {
1828.         $settings = $this->settings;
1829.         if ($settingName === SettingConstants::SOURCE) {
1830.             $originalSettingValue = $settingValue;
1831.             $settings[SettingConstants::SOURCE_RAW] = $originalSettingValue;
1832.             // todo: if setting string contains utm_content with json data, then decode and decrypt with fb key to attribute
1833.             if (str_contains($originalSettingValue, 'utm_content')) {
1834.                 $result = MetaAttributionHelper::extractData($originalSettingValue);
1835.                 if ($result !== null) {
1836.                     $settings[SettingConstants::SOURCE_ATTRIBUTION] = $result;
1837.                 }
1838.             }
1839.             // limit setting value to 255 chars
1840.             $settingValue = substr($settingValue, 0, 254);
1841.         }
1842.         $settings[$settingName] = $settingValue;
1843.         $this->setSettings($settings);
1844.     }
1846.     public function getSetting($settingName)
1847.     {
1848.         return $this->settings[$settingName] ?? null;
1849.     }
1851.     /**
1852.      * @return Collection|CommentLike[]
1853.      */
1854.     public function getCommentLikes(): Collection
1855.     {
1856.         return $this->commentLikes;
1857.     }
1859.     public function addCommentLike(CommentLike $commentLike): self
1860.     {
1861.         if (!$this->commentLikes->contains($commentLike)) {
1862.             $this->commentLikes[] = $commentLike;
1863.             $commentLike->setUser($this);
1864.         }
1866.         return $this;
1867.     }
1869.     public function removeCommentLike(CommentLike $commentLike): self
1870.     {
1871.         if ($this->commentLikes->removeElement($commentLike)) {
1872.             // set the owning side to null (unless already changed)
1873.             if ($commentLike->getUser() === $this) {
1874.                 $commentLike->setUser(null);
1875.             }
1876.         }
1878.         return $this;
1879.     }
1881.     /**
1882.      * @return Collection|Notification[]
1883.      */
1884.     public function getNotifications(): Collection
1885.     {
1886.         return $this->notifications;
1887.     }
1889.     public function addNotification(Notification $notification): self
1890.     {
1891.         if (!$this->notifications->contains($notification)) {
1892.             $this->notifications[] = $notification;
1893.             $notification->setUser($this);
1894.         }
1896.         return $this;
1897.     }
1899.     public function removeNotification(Notification $notification): self
1900.     {
1901.         if ($this->notifications->removeElement($notification)) {
1902.             // set the owning side to null (unless already changed)
1903.             if ($notification->getUser() === $this) {
1904.                 $notification->setUser(null);
1905.             }
1906.         }
1908.         return $this;
1909.     }
1911.     public function isModerator(): bool
1912.     {
1913.         // super moderators always have moderator privileges too
1914.         if ($this->isSuperModerator()) {
1915.             return true;
1916.         }
1917.         $settings = $this->getSettings();
1918.         return isset($settings[SettingConstants::IS_MODERATOR]) && $settings[SettingConstants::IS_MODERATOR] === true;
1919.     }
1921.     public function isSuperModerator(): bool
1922.     {
1923.         $settings = $this->getSettings();
1924.         return isset($settings[SettingConstants::IS_SUPER_MODERATOR]) && $settings[SettingConstants::IS_SUPER_MODERATOR] === true;
1925.     }
1927.     /**
1928.      * @return Collection|Nps[]
1929.      */
1930.     public function getNps(): Collection
1931.     {
1932.         return $this->nps;
1933.     }
1935.     public function addNp(Nps $np): self
1936.     {
1937.         if (!$this->nps->contains($np)) {
1938.             $this->nps[] = $np;
1939.             $np->setUser($this);
1940.         }
1942.         return $this;
1943.     }
1945.     public function removeNp(Nps $np): self
1946.     {
1947.         if ($this->nps->removeElement($np)) {
1948.             // set the owning side to null (unless already changed)
1949.             if ($np->getUser() === $this) {
1950.                 $np->setUser(null);
1951.             }
1952.         }
1954.         return $this;
1955.     }
1957.     /**
1958.      * @return Collection<int, UserConnection>
1959.      */
1960.     public function getUserConnections(): Collection
1961.     {
1962.         return $this->userConnections;
1963.     }
1965.     public function addUserConnection(UserConnection $userConnection): self
1966.     {
1967.         if (!$this->userConnections->contains($userConnection)) {
1968.             $this->userConnections[] = $userConnection;
1969.             $userConnection->setUser($this);
1970.         }
1972.         return $this;
1973.     }
1975.     public function removeUserConnection(UserConnection $userConnection): self
1976.     {
1977.         if ($this->userConnections->removeElement($userConnection)) {
1978.             // set the owning side to null (unless already changed)
1979.             if ($userConnection->getUser() === $this) {
1980.                 $userConnection->setUser(null);
1981.             }
1982.         }
1984.         return $this;
1985.     }
1987.     public function getDisplayName(): string
1988.     {
1989.         if ($this->nickname !== null && trim($this->nickname) !== '') {
1990.             return $this->nickname;
1991.         }
1992.         $name = $this->firstname;
1993.         if (!empty($this->lastname)) {
1994.             $name .= ' ' . mb_substr($this->lastname, 0, 1) . '.';
1995.         }
1996.         return $name ?? '';
1997.     }
1999.     /**
2000.      * @return Collection<int, Reminder>
2001.      */
2002.     public function getReminders(): Collection
2003.     {
2004.         return $this->reminders;
2005.     }
2007.     public function addReminder(Reminder $reminder): self
2008.     {
2009.         if (!$this->reminders->contains($reminder)) {
2010.             $this->reminders[] = $reminder;
2011.             $reminder->setUser($this);
2012.         }
2014.         return $this;
2015.     }
2017.     public function removeReminder(Reminder $reminder): self
2018.     {
2019.         if ($this->reminders->removeElement($reminder)) {
2020.             // set the owning side to null (unless already changed)
2021.             if ($reminder->getUser() === $this) {
2022.                 $reminder->setUser(null);
2023.             }
2024.         }
2026.         return $this;
2027.     }
2029.     public function setImageDataUri(string $uri): self
2030.     {
2031.         $this->imageDataUri = $uri;
2032.         return $this;
2033.     }
2035.     public function getImageDataUri(): string
2036.     {
2037.         return $this->imageDataUri;
2038.     }
2040.     /**
2041.      * @return Collection<int, ProfitwellUser>
2042.      */
2043.     public function getProfitwellUsers(): Collection
2044.     {
2045.         return $this->profitwellUsers;
2046.     }
2048.     public function addProfitwellUser(ProfitwellUser $profitwellUser): self
2049.     {
2050.         if (!$this->profitwellUsers->contains($profitwellUser)) {
2051.             $this->profitwellUsers[] = $profitwellUser;
2052.             $profitwellUser->setUser($this);
2053.         }
2055.         return $this;
2056.     }
2058.     public function removeProfitwellUser(ProfitwellUser $profitwellUser): self
2059.     {
2060.         if ($this->profitwellUsers->removeElement($profitwellUser)) {
2061.             // set the owning side to null (unless already changed)
2062.             if ($profitwellUser->getUser() === $this) {
2063.                 $profitwellUser->setUser(null);
2064.             }
2065.         }
2067.         return $this;
2068.     }
2071.     /**
2072.      * @return Collection<int, Template>
2073.      */
2074.     public function getTemplates(): Collection
2075.     {
2076.         return $this->templates;
2077.     }
2079.     public function addTemplate(Template $template): self
2080.     {
2081.         if (!$this->templates->contains($template)) {
2082.             $this->templates[] = $template;
2083.             $template->setCreatedByUser($this);
2084.         }
2086.         return $this;
2087.     }
2089.     public function removeTemplate(Template $template): self
2090.     {
2091.         if ($this->templates->removeElement($template)) {
2092.             // set the owning side to null (unless already changed)
2093.             if ($template->getCreatedByUser() === $this) {
2094.                 $template->setCreatedByUser(null);
2095.             }
2096.         }
2098.         return $this;
2099.     }
2101.     public function updateMentionTag(): self
2102.     {
2103.         $transformation = [" " => "_", "-" => "_", "#" => "", "@" => ""];
2104.         if (!empty($this->getNickname())) {
2105.             $sanitized = strtr($this->getNickname(), $transformation);
2106.             $this->setSetting('mentionTag', $sanitized);
2107.         }
2108.         return $this;
2109.     }
2111.     /**
2112.      * @return Collection<int, FavoriteTemplate>
2113.      */
2114.     public function getFavoriteTemplates(): Collection
2115.     {
2116.         return $this->favoriteTemplates;
2117.     }
2119.     public function addFavoriteTemplate(FavoriteTemplate $favoriteTemplate): self
2120.     {
2121.         if (!$this->favoriteTemplates->contains($favoriteTemplate)) {
2122.             $this->favoriteTemplates[] = $favoriteTemplate;
2123.             $favoriteTemplate->setUser($this);
2124.         }
2126.         return $this;
2127.     }
2129.     public function removeFavoriteTemplate(FavoriteTemplate $favoriteTemplate): self
2130.     {
2131.         if ($this->favoriteTemplates->removeElement($favoriteTemplate)) {
2132.             // set the owning side to null (unless already changed)
2133.             if ($favoriteTemplate->getUser() === $this) {
2134.                 $favoriteTemplate->setUser(null);
2135.             }
2136.         }
2138.         return $this;
2139.     }
2141.     /**
2142.      * @return Collection<int, TemplateUsage>
2143.      */
2144.     public function getTemplateUsages(): Collection
2145.     {
2146.         return $this->templateUsages;
2147.     }
2149.     public function addTemplateUsage(TemplateUsage $templateUsage): self
2150.     {
2151.         if (!$this->templateUsages->contains($templateUsage)) {
2152.             $this->templateUsages[] = $templateUsage;
2153.             $templateUsage->setUser($this);
2154.         }
2156.         return $this;
2157.     }
2159.     public function removeTemplateUsage(TemplateUsage $templateUsage): self
2160.     {
2161.         if ($this->templateUsages->removeElement($templateUsage)) {
2162.             // set the owning side to null (unless already changed)
2163.             if ($templateUsage->getUser() === $this) {
2164.                 $templateUsage->setUser(null);
2165.             }
2166.         }
2168.         return $this;
2169.     }
2171.     /**
2172.      * @return Collection<int, ObjectComment>
2173.      */
2174.     public function getObjectComments(): Collection
2175.     {
2176.         return $this->objectComments;
2177.     }
2179.     public function addObjectComment(ObjectComment $objectComment): self
2180.     {
2181.         if (!$this->objectComments->contains($objectComment)) {
2182.             $this->objectComments[] = $objectComment;
2183.             $objectComment->setUser($this);
2184.         }
2186.         return $this;
2187.     }
2189.     public function removeObjectComment(ObjectComment $objectComment): self
2190.     {
2191.         if ($this->objectComments->removeElement($objectComment)) {
2192.             // set the owning side to null (unless already changed)
2193.             if ($objectComment->getUser() === $this) {
2194.                 $objectComment->setUser(null);
2195.             }
2196.         }
2198.         return $this;
2199.     }
2201.     /**
2202.      * @return Collection<int, PreferencesToken>
2203.      */
2204.     public function getPreferencesTokens(): Collection
2205.     {
2206.         return $this->preferencesTokens;
2207.     }
2209.     public function addPreferencesToken(PreferencesToken $preferencesToken): self
2210.     {
2211.         if (!$this->preferencesTokens->contains($preferencesToken)) {
2212.             $this->preferencesTokens[] = $preferencesToken;
2213.             $preferencesToken->setUser($this);
2214.         }
2216.         return $this;
2217.     }
2219.     public function removePreferencesToken(PreferencesToken $preferencesToken): self
2220.     {
2221.         if ($this->preferencesTokens->removeElement($preferencesToken)) {
2222.             // set the owning side to null (unless already changed)
2223.             if ($preferencesToken->getUser() === $this) {
2224.                 $preferencesToken->setUser(null);
2225.             }
2226.         }
2228.         return $this;
2229.     }
2231.     /**
2232.      * @return Collection<int, Usercontent>
2233.      */
2234.     public function getUsercontents(): Collection
2235.     {
2236.         return $this->usercontents;
2237.     }
2239.     public function addUsercontent(Usercontent $usercontent): self
2240.     {
2241.         if (!$this->usercontents->contains($usercontent)) {
2242.             $this->usercontents[] = $usercontent;
2243.             $usercontent->setUser($this);
2244.         }
2246.         return $this;
2247.     }
2249.     public function removeUsercontent(Usercontent $usercontent): self
2250.     {
2251.         if ($this->usercontents->removeElement($usercontent)) {
2252.             // set the owning side to null (unless already changed)
2253.             if ($usercontent->getUser() === $this) {
2254.                 $usercontent->setUser(null);
2255.             }
2256.         }
2258.         return $this;
2259.     }
2261.     /**
2262.      * @return Collection<int, TagConnection>
2263.      */
2264.     public function getTagConnections(): Collection
2265.     {
2266.         return $this->tagConnections;
2267.     }
2269.     public function addTagConnection(TagConnection $tagConnection): self
2270.     {
2271.         if (!$this->tagConnections->contains($tagConnection)) {
2272.             $this->tagConnections[] = $tagConnection;
2273.             $tagConnection->setUser($this);
2274.         }
2276.         return $this;
2277.     }
2279.     public function removeTagConnection(TagConnection $tagConnection): self
2280.     {
2281.         if ($this->tagConnections->removeElement($tagConnection)) {
2282.             // set the owning side to null (unless already changed)
2283.             if ($tagConnection->getUser() === $this) {
2284.                 $tagConnection->setUser(null);
2285.             }
2286.         }
2288.         return $this;
2289.     }
2291.     /**
2292.      * @return Collection<int, Croplist>
2293.      */
2294.     public function getCropLists(): Collection
2295.     {
2296.         return $this->cropLists;
2297.     }
2299.     public function addCropList(Croplist $cropList): self
2300.     {
2301.         if (!$this->cropLists->contains($cropList)) {
2302.             $this->cropLists->add($cropList);
2303.             $cropList->setUser($this);
2304.         }
2306.         return $this;
2307.     }
2309.     public function removeCropList(Croplist $cropList): self
2310.     {
2311.         if ($this->cropLists->removeElement($cropList)) {
2312.             // set the owning side to null (unless already changed)
2313.             if ($cropList->getUser() === $this) {
2314.                 $cropList->setUser(null);
2315.             }
2316.         }
2318.         return $this;
2319.     }
2321.     public function getLocale(): ?string
2322.     {
2323.         return $this->locale;
2324.     }
2326.     public function setLocale(?string $locale): static
2327.     {
2328.         $this->locale = $locale;
2330.         return $this;
2331.     }
2333.     /**
2334.      * @return Collection<int, CancellationSurvey>
2335.      */
2336.     public function getCancellationSurveys(): Collection
2337.     {
2338.         return $this->cancellationSurveys;
2339.     }
2341.     public function addCancellationSurvey(CancellationSurvey $cancellationSurvey): static
2342.     {
2343.         if (!$this->cancellationSurveys->contains($cancellationSurvey)) {
2344.             $this->cancellationSurveys->add($cancellationSurvey);
2345.             $cancellationSurvey->setUser($this);
2346.         }
2348.         return $this;
2349.     }
2351.     public function removeCancellationSurvey(CancellationSurvey $cancellationSurvey): static
2352.     {
2353.         if ($this->cancellationSurveys->removeElement($cancellationSurvey)) {
2354.             // set the owning side to null (unless already changed)
2355.             if ($cancellationSurvey->getUser() === $this) {
2356.                 $cancellationSurvey->setUser(null);
2357.             }
2358.         }
2360.         return $this;
2361.     }
2363.     /**
2364.      * @return Collection<int, ModerationNotification>
2365.      */
2366.     public function getModerationNotifications(): Collection
2367.     {
2368.         return $this->moderationNotifications;
2369.     }
2371.     public function addModerationNotification(ModerationNotification $moderationNotification): static
2372.     {
2373.         if (!$this->moderationNotifications->contains($moderationNotification)) {
2374.             $this->moderationNotifications->add($moderationNotification);
2375.             $moderationNotification->setUser($this);
2376.         }
2378.         return $this;
2379.     }
2381.     public function removeModerationNotification(ModerationNotification $moderationNotification): static
2382.     {
2383.         if ($this->moderationNotifications->removeElement($moderationNotification)) {
2384.             // set the owning side to null (unless already changed)
2385.             if ($moderationNotification->getUser() === $this) {
2386.                 $moderationNotification->setUser(null);
2387.             }
2388.         }
2390.         return $this;
2391.     }
2393.     public function getTest(): ?string
2394.     {
2395.         return $this->test;
2396.     }
2398.     public function setTest(string $test): static
2399.     {
2400.         $this->test = $test;
2402.         return $this;
2403.     }
2405.     public function getClimateSettings(): ?array
2406.     {
2407.         return $this->climate_settings;
2408.     }
2410.     public function setClimateSettings(?array $climate_settings): static
2411.     {
2412.         $this->climate_settings = $climate_settings;
2414.         return $this;
2415.     }
2417.     public function getUnits(): ?array
2418.     {
2419.         return $this->units;
2420.     }
2422.     public function setUnits(?array $units): static
2423.     {
2424.         $this->units = $units;
2426.         return $this;
2427.     }
2429.     /**
2430.      * @return Collection<int, PostReport>
2431.      */
2432.     public function getPostReports(): Collection
2433.     {
2434.         return $this->postReports;
2435.     }
2437.     public function addPostReport(PostReport $postReport): static
2438.     {
2439.         if (!$this->postReports->contains($postReport)) {
2440.             $this->postReports->add($postReport);
2441.             $postReport->setReportedByUserId($this);
2442.         }
2444.         return $this;
2445.     }
2447.     public function removePostReport(PostReport $postReport): static
2448.     {
2449.         if ($this->postReports->removeElement($postReport)) {
2450.             // set the owning side to null (unless already changed)
2451.             if ($postReport->getReportedByUserId() === $this) {
2452.                 $postReport->setReportedByUserId(null);
2453.             }
2454.         }
2456.         return $this;
2457.     }
2458. }