src/Entity/User.php line 70

1. <?php
3. namespace App\Entity;
5. use Doctrine\Common\Collections\ArrayCollection;
6. use Doctrine\Common\Collections\Collection;
7. use ApiPlatform\Metadata\ApiFilter;
8. use ApiPlatform\Metadata\ApiProperty;
9. use ApiPlatform\Metadata\ApiResource;
10. use ApiPlatform\Metadata\Delete;
11. use ApiPlatform\Metadata\Get;
12. use ApiPlatform\Metadata\GetCollection;
13. use ApiPlatform\Metadata\Patch;
14. use ApiPlatform\Metadata\Post;
15. use ApiPlatform\Metadata\Put;
16. use Doctrine\DBAL\Types\Types;
17. use Doctrine\ORM\Mapping as ORM;
18. use App\Repository\UserRepository;
19. use App\State\UserPasswordHasher;
20. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
21. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
22. use Symfony\Component\Security\Core\User\UserInterface;
23. use Symfony\Component\Serializer\Annotation\Groups;
24. use Symfony\Component\Validator\Constraints as Assert;
25. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
26. use App\Controller\UserController;
27. use App\Filter\CustomOrFilter; // Змініть імпорт на правильний
30. #[ORM\Table(name: 'users')]
31. #[ApiResource(
32.     operations: [
33.         new GetCollection(),
34.         new Post(processor: UserPasswordHasher::class, validationContext: ['groups' => ['Default', 'user:create']]),
35.         new Get(),
36.         new Put(processor: UserPasswordHasher::class),
37.         new Patch(processor: UserPasswordHasher::class),
38.         new Post(
39.             name: 'me', 
40.             uriTemplate: '/users/me', 
41.             controller: UserController::class
42.         ),
43.         new Get(
44.             name: 'user_search', 
45.             uriTemplate: '/user/search', 
46.             controller: UserController::class
47.         )
48.     ],
49.     normalizationContext: ['groups' => ['user:read']],
50.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
52. )]
53. #[ORM\Entity(repositoryClass: UserRepository::class)]
54. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
55. #[ApiFilter(CustomOrFilter::class,properties: [
56.     'username' => 'ipartial', 
57.     'firstName' => 'ipartial', 
58.     'lastName' => 'ipartial',
59.     'codeUser' => 'exact',
60.     'codeManager' => 'exact',
61. ])]
63. #[ApiFilter(SearchFilter::class, properties: [
65.     'accounts.manager.id' => 'exact',
66.     'userType' => 'exact',
67.     'appPersonalAccounts.number' => 'exact',
68. ])]
70. class User implements UserInterface, PasswordAuthenticatedUserInterface
71. {
72.     #[ORM\Id]
73.     #[ORM\GeneratedValue]
74.     #[ORM\Column]
75.     #[Groups(['user:read', 'read', 'account:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'product_storage_balance:read', 'personalAcc:read', 'Notification:read', 'MassiveNotification:read'])]
76.     private ?int $id = null;
78.     #[ORM\Column(length: 180, unique: true)]
79.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'Notification:read', 'MassiveNotification:read'])]
80.     private ?string $username = null;
82.     #[Groups(['user:read', 'user:update'])]
83.     #[ORM\Column]
84.     private array $roles = [];
86.     /**
87.      * @var string The hashed password
88.      */
89.     #[ORM\Column]
90.     private ?string $password = null;
92.     #[Assert\NotBlank(groups: ['user:create'])]
93.     #[Groups(['user:create', 'user:update'])]
94.     private ?string $plainPassword = null;
97.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'firstName')]
98.     private ?self $manager = null;
100.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'account:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'product_storage_balance:read', 'personalAcc:read', 'Notification:read', 'MassiveNotification:read'])]
101.     #[ORM\Column(length: 255, nullable: true)]
102.     private ?string $firstName  = null;
104.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'account:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'product_storage_balance:read', 'personalAcc:read', 'Notification:read', 'MassiveNotification:read'])]
105.     #[ORM\Column(length: 255, nullable: true)]
106.     private ?string $lastName = null;
108.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read', 'personalAcc:read'])]
109.     #[ORM\Column(length: 100, nullable: true)]
110.     private ?string $phone = null;
112.     #[Groups(['user:read', 'user:create', 'user:update'])]
113.     #[ORM\Column(length: 255, nullable: true)]
114.     private ?string $address = null; 
116.     #[Groups(['user:read', 'user:create', 'user:update'])]
117.     #[ORM\Column(length: 50, nullable: true)]
118.     private ?string $status = null;
120.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'personalAcc:read'])]
121.     #[ORM\Column(length: 255, nullable: true)]
122.     private ?string $email = null;
124.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
125.     #[ORM\Column(length: 255, nullable: true)]
126.     private ?string $workSchedule = null;
128.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
129.     #[ORM\Column(length: 255, nullable: true)]
130.     private ?string $telegram = null;
132.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
133.     #[ORM\Column(length: 255, nullable: true)]
134.     private ?string $viber = null;
136.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
137.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
138.     private Collection $mediaObjects;
140.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
141.     private ?\DateTimeInterface $hashDate = null;
143.     #[ORM\Column(length: 255, nullable: true)]
144.     private ?string $device_id = null;
146.     #[ORM\Column(length: 10, nullable: true)]
147.     private ?string $activeCode = null;
149.     #[ORM\Column(nullable: true)]
150.     private ?bool $deleted = null;
152.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UserToken::class)]
153.     private Collection $userTokens;
155.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: AppPersonalAccount::class, orphanRemoval: true)]
156.     private Collection $appPersonalAccounts;
158.     #[ORM\Column(nullable: true)]
159.     private ?int $debug = null;
161.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Notification::class)]
162.     private Collection $notifications;
164.     #[ORM\Column(nullable: true)]
165.     private ?bool $dev = null;
167.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
168.     private ?\DateTimeInterface $dateEntered = null;
170.     #[ORM\OneToMany(mappedBy: 'userCreated', targetEntity: MassiveNotification::class)]
171.     private Collection $massiveNotifications;
175.     public function __construct()
176.     {
177.         $this->mediaObjects = new ArrayCollection();
178.         $this->userTokens = new ArrayCollection();
179.         $this->appPersonalAccounts = new ArrayCollection();
180.         $this->notifications = new ArrayCollection();
181.         $this->massiveNotifications = new ArrayCollection();
182.     }
184.     public function getId(): ?int
185.     {
186.         return $this->id;
187.     }
189.     /**
190.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
191.      */
192.     public function getUsername(): string
193.     {
194.         return (string) $this->username;
195.     }
197.     public function setUsername(string $username): self
198.     {
199.         $this->username = $username;
201.         return $this;
202.     }
204.     /**
205.      * A visual identifier that represents this user.
206.      *
207.      * @see UserInterface
208.      */
209.     public function getUserIdentifier(): string
210.     {
211.         return (string) $this->username;
212.     }
214.     /**
215.      * @see UserInterface
216.      */
217.     public function getRoles(): array
218.     {
219.         $roles = $this->roles;
220.         // guarantee every user at least has ROLE_USER
221.         $roles[] = 'ROLE_USER';
223.         return array_unique($roles);
224.     }
226.     public function setRoles(array $roles): self
227.     {
228.         $this->roles = $roles;
230.         return $this;
231.     }
233.     /**
234.      * @see PasswordAuthenticatedUserInterface
235.      */
236.     public function getPassword(): string
237.     {
238.         return $this->password;
239.     }
241.     public function setPassword(string $password): self
242.     {
243.         $this->password = $password;
245.         return $this;
246.     }
248.     public function getPlainPassword(): ?string
249.     {
250.         return $this->plainPassword;
251.     }
253.     public function setPlainPassword(?string $plainPassword): self
254.     {
255.         $this->plainPassword = $plainPassword;
257.         return $this;
258.     }
260.     /**
261.      * Returning a salt is only needed, if you are not using a modern
262.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
263.      *
264.      * @see UserInterface
265.      */
266.     public function getSalt(): ?string
267.     {
268.         return null;
269.     }
271.     /**
272.      * @see UserInterface
273.      */
274.     public function eraseCredentials()
275.     {
276.         // If you store any temporary, sensitive data on the user, clear it here
277.         $this->plainPassword = null;
278.     }
280.     public function getManagerId(): ?self
281.     {
282.         return $this->manager;
283.     }
285.     public function setManagerId(?self $manager): self
286.     {
287.         $this->manager = $manager;
289.         return $this;
290.     }
291.     
292.     public function getFirstName(): ?string
293.     {
294.         return $this->firstName;
295.     }
298.     public function setFirstName(string $firstName): self
299.     {
300.         $this->firstName = $firstName;
302.         return $this;
303.     }
305.     public function getLastName(): ?string
306.     {
307.         return $this->lastName;
308.     }
310.     public function setLastName(string $lastName): self
311.     {
312.         $this->lastName = $lastName;
314.         return $this;
315.     }
317.     public function getPhone(): ?string
318.     {
319.         return $this->phone;
320.     }
322.     public function setPhone(?string $phone): self
323.     {
324.         $this->phone = $phone;
326.         return $this;
327.     }
329.     public function getAddress(): ?string
330.     {
331.         return $this->address;
332.     }
334.     public function setAddress(?string $address): self
335.     {
336.         $this->address = $address;
338.         return $this;
339.     }
341.     public function getStatus(): ?string
342.     {
343.         return $this->status;
344.     }
346.     public function setStatus(?string $status): self
347.     {
348.         $this->status = $status;
350.         return $this;
351.     }
353.     // /**
354.     //  * @return Collection<int, UserLikeList>
355.     //  */
356.     // public function getUserLikeLists(): Collection
357.     // {
358.     //     return $this->userLikeLists;
359.     // }
361.     // public function addUserLikeList(UserLikeList $userLikeList): self
362.     // {
363.     //     if (!$this->userLikeLists->contains($userLikeList)) {
364.     //         $this->userLikeLists->add($userLikeList);
365.     //         $userLikeList->setUserId($this);
366.     //     }
368.     //     return $this;
369.     // }
371.     // public function removeUserLikeList(UserLikeList $userLikeList): self
372.     // {
373.     //     if ($this->userLikeLists->removeElement($userLikeList)) {
374.     //         // set the owning side to null (unless already changed)
375.     //         if ($userLikeList->getUserId() === $this) {
376.     //             $userLikeList->setUserId(null);
377.     //         }
378.     //     }
380.     //     return $this;
381.     // }
383.     // /**
384.     //  * @return Collection<int, Products>
385.     //  */
386.     // public function getProducts(): Collection
387.     // {
388.     //     return $this->products;
389.     // }
391.     // public function addProduct(Products $product): self
392.     // {
393.     //     if (!$this->products->contains($product)) {
394.     //         $this->products->add($product);
395.     //         $product->setModifiedUserId($this);
396.     //     }
398.     //     return $this;
399.     // }
401.     // public function removeProduct(Products $product): self
402.     // {
403.     //     if ($this->products->removeElement($product)) {
404.     //         // set the owning side to null (unless already changed)
405.     //         if ($product->getModifiedUserId() === $this) {
406.     //             $product->setModifiedUserId(null);
407.     //         }
408.     //     }
410.     //     return $this;
411.     // }
413.     // /**
414.     //  * @return Collection<int, Products>
415.     //  */
416.     // public function getCreateProducts(): Collection
417.     // {
418.     //     return $this->create_products;
419.     // }
421.     // public function addCreateProduct(Products $createProduct): self
422.     // {
423.     //     if (!$this->create_products->contains($createProduct)) {
424.     //         $this->create_products->add($createProduct);
425.     //         $createProduct->setCreatedBy($this);
426.     //     }
428.     //     return $this;
429.     // }
431.     // public function removeCreateProduct(Products $createProduct): self
432.     // {
433.     //     if ($this->create_products->removeElement($createProduct)) {
434.     //         // set the owning side to null (unless already changed)
435.     //         if ($createProduct->getCreatedBy() === $this) {
436.     //             $createProduct->setCreatedBy(null);
437.     //         }
438.     //     }
440.     //     return $this;
441.     // }
443.     // /**
444.     //  * @return Collection<int, Orders>
445.     //  */
446.     // public function getOrders(): Collection
447.     // {
448.     //     return $this->orders;
449.     // }
451.     // public function addOrder(Orders $order): self
452.     // {
453.     //     if (!$this->orders->contains($order)) {
454.     //         $this->orders->add($order);
455.     //         $order->setUserId($this);
456.     //     }
458.     //     return $this;
459.     // }
461.     // public function removeOrder(Orders $order): self
462.     // {
463.     //     if ($this->orders->removeElement($order)) {
464.     //         // set the owning side to null (unless already changed)
465.     //         if ($order->getUserId() === $this) {
466.     //             $order->setUserId(null);
467.     //         }
468.     //     }
470.     //     return $this;
471.     // }
473.     // /**
474.     //  * @return Collection<int, Orders>
475.     //  */
476.     // public function getManagerOrders(): Collection
477.     // {
478.     //     return $this->managerOrders;
479.     // }
481.     // public function addManagerOrder(Orders $managerOrder): self
482.     // {
483.     //     if (!$this->managerOrders->contains($managerOrder)) {
484.     //         $this->managerOrders->add($managerOrder);
485.     //         $managerOrder->setManagerId($this);
486.     //     }
488.     //     return $this;
489.     // }
491.     // public function removeManagerOrder(Orders $managerOrder): self
492.     // {
493.     //     if ($this->managerOrders->removeElement($managerOrder)) {
494.     //         // set the owning side to null (unless already changed)
495.     //         if ($managerOrder->getManagerId() === $this) {
496.     //             $managerOrder->setManagerId(null);
497.     //         }
498.     //     }
500.     //     return $this;
501.     // }
503.     public function getEmail(): ?string
504.     {
505.         return $this->email;
506.     }
508.     public function setEmail(?string $email): self
509.     {
510.         $this->email = $email;
512.         return $this;
513.     }
515.     // /**
516.     //  * @return Collection<int, Accounts>
517.     //  */
518.     // public function getAccounts(): Collection
519.     // {
520.     //     return $this->accounts;
521.     // }
523.     // public function addAccount(Accounts $account): self
524.     // {
525.     //     if (!$this->accounts->contains($account)) {
526.     //         $this->accounts->add($account);
527.     //         $account->setUserId($this);
528.     //     }
530.     //     return $this;
531.     // }
533.     // public function removeAccount(Accounts $account): self
534.     // {
535.     //     if ($this->accounts->removeElement($account)) {
536.     //         // set the owning side to null (unless already changed)
537.     //         if ($account->getUserId() === $this) {
538.     //             $account->setUserId(null);
539.     //         }
540.     //     }
542.     //     return $this;
543.     // }
545.     // /**
546.     //  * @return Collection<int, LoadInvoice>
547.     //  */
548.     // public function getLoadInvoices(): Collection
549.     // {
550.     //     return $this->loadInvoices;
551.     // }
553.     // public function addLoadInvoice(LoadInvoice $loadInvoice): self
554.     // {
555.     //     if (!$this->loadInvoices->contains($loadInvoice)) {
556.     //         $this->loadInvoices->add($loadInvoice);
557.     //         $loadInvoice->setClient($this);
558.     //     }
560.     //     return $this;
561.     // }
563.     // public function removeLoadInvoice(LoadInvoice $loadInvoice): self
564.     // {
565.     //     if ($this->loadInvoices->removeElement($loadInvoice)) {
566.     //         // set the owning side to null (unless already changed)
567.     //         if ($loadInvoice->getClient() === $this) {
568.     //             $loadInvoice->setClient(null);
569.     //         }
570.     //     }
572.     //     return $this;
573.     // }
575.     // /**
576.     //  * @return Collection<int, Accepted>
577.     //  */
578.     // public function getAccepteds(): Collection
579.     // {
580.     //     return $this->accepteds;
581.     // }
583.     // public function addAccepted(Accepted $accepted): self
584.     // {
585.     //     if (!$this->accepteds->contains($accepted)) {
586.     //         $this->accepteds->add($accepted);
587.     //         $accepted->setManager($this);
588.     //     }
590.     //     return $this;
591.     // }
593.     // public function removeAccepted(Accepted $accepted): self
594.     // {
595.     //     if ($this->accepteds->removeElement($accepted)) {
596.     //         // set the owning side to null (unless already changed)
597.     //         if ($accepted->getManager() === $this) {
598.     //             $accepted->setManager(null);
599.     //         }
600.     //     }
602.     //     return $this;
603.     // }
605.     // /**
606.     //  * @return Collection<int, AcceptedProduct>
607.     //  */
608.     // public function getN(): Collection
609.     // {
610.     //     return $this->n;
611.     // }
613.     // public function addN(AcceptedProduct $n): self
614.     // {
615.     //     if (!$this->n->contains($n)) {
616.     //         $this->n->add($n);
617.     //         $n->setModifiedUser($this);
618.     //     }
620.     //     return $this;
621.     // }
623.     // public function removeN(AcceptedProduct $n): self
624.     // {
625.     //     if ($this->n->removeElement($n)) {
626.     //         // set the owning side to null (unless already changed)
627.     //         if ($n->getModifiedUser() === $this) {
628.     //             $n->setModifiedUser(null);
629.     //         }
630.     //     }
632.     //     return $this;
633.     // }
635.     // public function getCodeUser(): ?string
636.     // {
637.     //     return $this->codeUser;
638.     // }
640.     // public function setCodeUser(string $codeUser): self
641.     // {
642.     //     $this->codeUser = $codeUser;
644.     //     return $this;
645.     // }
647.     // public function getCodeManager(): ?string
648.     // {
649.     //     return $this->codeManager;
650.     // }
652.     // public function setCodeManager(string $codeManager): self
653.     // {
654.     //     $this->codeManager = $codeManager;
656.     //     return $this;
657.     // }
659.     // /**
660.     //  * @return Collection<int, Accounts>
661.     //  */
662.     // public function getManagerAccounts(): Collection
663.     // {
664.     //     return $this->managerAccounts;
665.     // }
667.     // public function addManagerAccount(Accounts $managerAccount): self
668.     // {
669.     //     if (!$this->managerAccounts->contains($managerAccount)) {
670.     //         $this->managerAccounts->add($managerAccount);
671.     //         $managerAccount->setManager($this);
672.     //     }
674.     //     return $this;
675.     // }
677.     // public function removeManagerAccount(Accounts $managerAccount): self
678.     // {
679.     //     if ($this->managerAccounts->removeElement($managerAccount)) {
680.     //         // set the owning side to null (unless already changed)
681.     //         if ($managerAccount->getManager() === $this) {
682.     //             $managerAccount->setManager(null);
683.     //         }
684.     //     }
686.     //     return $this;
687.     // }
689.     // /**
690.     //  * @return Collection<int, PreOrder>
691.     //  */
692.     // public function getPreOrders(): Collection
693.     // {
694.     //     return $this->preOrders;
695.     // }
697.     // public function addPreOrder(PreOrder $preOrder): self
698.     // {
699.     //     if (!$this->preOrders->contains($preOrder)) {
700.     //         $this->preOrders->add($preOrder);
701.     //         $preOrder->setClient($this);
702.     //     }
704.     //     return $this;
705.     // }
707.     // public function removePreOrder(PreOrder $preOrder): self
708.     // {
709.     //     if ($this->preOrders->removeElement($preOrder)) {
710.     //         // set the owning side to null (unless already changed)
711.     //         if ($preOrder->getClient() === $this) {
712.     //             $preOrder->setClient(null);
713.     //         }
714.     //     }
716.     //     return $this;
717.     // }
719.     // /**
720.     //  * @return Collection<int, PreOrder>
721.     //  */
722.     // public function getManagerPreOrders(): Collection
723.     // {
724.     //     return $this->ManagerPreOrders;
725.     // }
727.     // public function addManagerPreOrder(PreOrder $managerPreOrder): self
728.     // {
729.     //     if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
730.     //         $this->ManagerPreOrders->add($managerPreOrder);
731.     //         $managerPreOrder->setManager($this);
732.     //     }
734.     //     return $this;
735.     // }
737.     // public function removeManagerPreOrder(PreOrder $managerPreOrder): self
738.     // {
739.     //     if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
740.     //         // set the owning side to null (unless already changed)
741.     //         if ($managerPreOrder->getManager() === $this) {
742.     //             $managerPreOrder->setManager(null);
743.     //         }
744.     //     }
746.     //     return $this;
747.     // }
749.     // public function getWorkSchedule(): ?string
750.     // {
751.     //     return $this->workSchedule;
752.     // }
754.     // public function setWorkSchedule(?string $workSchedule): self
755.     // {
756.     //     $this->workSchedule = $workSchedule;
758.     //     return $this;
759.     // }
761.     // public function getTelegram(): ?string
762.     // {
763.     //     return $this->telegram;
764.     // }
766.     // public function setTelegram(?string $telegram): self
767.     // {
768.     //     $this->telegram = $telegram;
770.     //     return $this;
771.     // }
773.     // public function getViber(): ?string
774.     // {
775.     //     return $this->viber;
776.     // }
778.     // public function setViber(?string $viber): self
779.     // {
780.     //     $this->viber = $viber;
782.     //     return $this;
783.     // }
785.     /**
786.      * @return Collection<int, MediaObject>
787.      */
788.     public function getMediaObjects(): Collection
789.     {
790.         return $this->mediaObjects;
791.     }
793.     public function addMediaObject(MediaObject $mediaObject): self
794.     {
795.         if (!$this->mediaObjects->contains($mediaObject)) {
796.             $this->mediaObjects->add($mediaObject);
797.             $mediaObject->setUsers($this);
798.         }
800.         return $this;
801.     }
803.     public function removeMediaObject(MediaObject $mediaObject): self
804.     {
805.         if ($this->mediaObjects->removeElement($mediaObject)) {
806.             // set the owning side to null (unless already changed)
807.             if ($mediaObject->getUsers() === $this) {
808.                 $mediaObject->setUsers(null);
809.             }
810.         }
812.         return $this;
813.     }
815.     // /**
816.     //  * @return Collection<int, Coupons>
817.     //  */
818.     // public function getCoupons(): Collection
819.     // {
820.     //     return $this->coupons;
821.     // }
823.     // public function addCoupon(Coupons $coupon): self
824.     // {
825.     //     if (!$this->coupons->contains($coupon)) {
826.     //         $this->coupons->add($coupon);
827.     //         $coupon->addUser($this);
828.     //     }
830.     //     return $this;
831.     // }
833.     // public function removeCoupon(Coupons $coupon): self
834.     // {
835.     //     if ($this->coupons->removeElement($coupon)) {
836.     //         $coupon->removeUser($this);
837.     //     }
839.     //     return $this;
840.     // }
842.     // /**
843.     //  * @return Collection<int, ProductBalanceInStorage>
844.     //  */
845.     // public function getProductBalanceInStorages(): Collection
846.     // {
847.     //     return $this->productBalanceInStorages;
848.     // }
850.     // public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
851.     // {
852.     //     if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
853.     //         $this->productBalanceInStorages->add($productBalanceInStorage);
854.     //         $productBalanceInStorage->setManager($this);
855.     //     }
857.     //     return $this;
858.     // }
860.     // public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
861.     // {
862.     //     if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
863.     //         // set the owning side to null (unless already changed)
864.     //         if ($productBalanceInStorage->getManager() === $this) {
865.     //             $productBalanceInStorage->setManager(null);
866.     //         }
867.     //     }
869.     //     return $this;
870.     // }
872.     // public function getEmployed(): ?string
873.     // {
874.     //     return $this->employed;
875.     // }
877.     // public function setEmployed(?string $employed): static
878.     // {
879.     //     $this->employed = $employed;
881.     //     return $this;
882.     // }
884.     // public function getAge(): ?string
885.     // {
886.     //     return $this->age;
887.     // }
889.     // public function setAge(?string $age): static
890.     // {
891.     //     $this->age = $age;
893.     //     return $this;
894.     // }
896.     // public function getExDirector(): ?string
897.     // {
898.     //     return $this->exDirector;
899.     // }
901.     // public function setExDirector(?string $exDirector): static
902.     // {
903.     //     $this->exDirector = $exDirector;
905.     //     return $this;
906.     // }
908.     // public function getCurrentDirector(): ?string
909.     // {
910.     //     return $this->currentDirector;
911.     // }
913.     // public function setCurrentDirector(?string $currentDirector): static
914.     // {
915.     //     $this->currentDirector = $currentDirector;
917.     //     return $this;
918.     // }
920.     // public function getGender(): ?string
921.     // {
922.     //     return $this->gender;
923.     // }
925.     // public function setGender(?string $gender): static
926.     // {
927.     //     $this->gender = $gender;
929.     //     return $this;
930.     // }
932.     // public function getSupportType(): array
933.     // {
934.     //     return $this->supportType;
935.     // }
937.     // public function setSupportType(?array $supportType): static
938.     // {
939.     //     $this->supportType = $supportType;
941.     //     return $this;
942.     // }
944.     // public function getaddressFrom(): ?string
945.     // {
946.     //     return $this->addressFrom;
947.     // }
949.     // public function setaddressFrom(?string $addressFrom): static
950.     // {
951.     //     $this->addressFrom = $addressFrom;
953.     //     return $this;
954.     // }
956.     // public function getAnotherProgram(): ?string
957.     // {
958.     //     return $this->anotherProgram;
959.     // }
961.     // public function setAnotherProgram(?string $anotherProgram): static
962.     // {
963.     //     $this->anotherProgram = $anotherProgram;
965.     //     return $this;
966.     // }
968.     // public function getRegionFrom(): ?string
969.     // {
970.     //     return $this->regionFrom;
971.     // }
973.     // public function setRegionFrom(?string $regionFrom): static
974.     // {
975.     //     $this->regionFrom = $regionFrom;
977.     //     return $this;
978.     // }
980.     // public function getNumberFOP(): ?string
981.     // {
982.     //     return $this->numberFOP;
983.     // }
985.     // public function setNumberFOP(?string $numberFOP): static
986.     // {
987.     //     $this->numberFOP = $numberFOP;
989.     //     return $this;
990.     // }
992.     // public function getCodeEDRPOU(): ?string
993.     // {
994.     //     return $this->codeEDRPOU;
995.     // }
997.     // public function setCodeEDRPOU(?string $codeEDRPOU): static
998.     // {
999.     //     $this->codeEDRPOU = $codeEDRPOU;
1001.     //     return $this;
1002.     // }
1004.     // public function getGrantSupport(): ?string
1005.     // {
1006.     //     return $this->grantSupport;
1007.     // }
1009.     // public function setGrantSupport(?string $grantSupport): static
1010.     // {
1011.     //     $this->grantSupport = $grantSupport;
1013.     //     return $this;
1014.     // }
1016.     // public function getCompanyName(): ?string
1017.     // {
1018.     //     return $this->companyName;
1019.     // }
1021.     // public function setCompanyName(?string $companyName): static
1022.     // {
1023.     //     $this->companyName = $companyName;
1025.     //     return $this;
1026.     // }
1028.     // public function getUserType(): ?string
1029.     // {
1030.     //     return $this->userType;
1031.     // }
1033.     // public function setUserType(string $userType): static
1034.     // {
1035.     //     $this->userType = $userType;
1037.     //     return $this;
1038.     // }
1040.     // public function isIsSentForPYSupport(): ?bool
1041.     // {
1042.     //     return $this->isSentForPYSupport;
1043.     // }
1045.     // public function setIsSentForPYSupport(?bool $isSentForPYSupport): static
1046.     // {
1047.     //     $this->isSentForPYSupport = $isSentForPYSupport;
1049.     //     return $this;
1050.     // }
1052.     // public function getHash(): ?string
1053.     // {
1054.     //     return $this->hash;
1055.     // }
1057.     // public function setHash(?string $hash): static
1058.     // {
1059.     //     $this->hash = $hash;
1061.     //     return $this;
1062.     // }
1064.     // public function isEmailVerified(): ?bool
1065.     // {
1066.     //     return $this->emailVerified;
1067.     // }
1069.     // public function setEmailVerified(?bool $emailVerified): static
1070.     // {
1071.     //     $this->emailVerified = $emailVerified;
1073.     //     return $this;
1074.     // }
1076.     public function getHashDate(): ?\DateTimeInterface
1077.     {
1078.         return $this->hashDate;
1079.     }
1081.     public function setHashDate(?\DateTimeInterface $hashDate): static
1082.     {
1083.         $this->hashDate = $hashDate;
1085.         return $this;
1086.     }
1088.     public function getDeviceId(): ?string
1089.     {
1090.         return $this->device_id;
1091.     }
1093.     public function setDeviceId(?string $device_id): static
1094.     {
1095.         $this->device_id = $device_id;
1097.         return $this;
1098.     }
1100.     public function getActiveCode(): ?string
1101.     {
1102.         return $this->activeCode;
1103.     }
1105.     public function setActiveCode(?string $activeCode): static
1106.     {
1107.         $this->activeCode = $activeCode;
1109.         return $this;
1110.     }
1112.     public function isDeleted(): ?bool
1113.     {
1114.         return $this->deleted;
1115.     }
1117.     public function setDeleted(?bool $deleted): static
1118.     {
1119.         $this->deleted = $deleted;
1121.         return $this;
1122.     }
1124.     /**
1125.      * @return Collection<int, UserToken>
1126.      */
1127.     public function getUserTokens(): Collection
1128.     {
1129.         return $this->userTokens;
1130.     }
1132.     public function addUserToken(UserToken $userToken): static
1133.     {
1134.         if (!$this->userTokens->contains($userToken)) {
1135.             $this->userTokens->add($userToken);
1136.             $userToken->setUsers($this);
1137.         }
1139.         return $this;
1140.     }
1142.     public function removeUserToken(UserToken $userToken): static
1143.     {
1144.         if ($this->userTokens->removeElement($userToken)) {
1145.             // set the owning side to null (unless already changed)
1146.             if ($userToken->getUsers() === $this) {
1147.                 $userToken->setUsers(null);
1148.             }
1149.         }
1151.         return $this;
1152.     }
1154.     /**
1155.      * @return Collection<int, AppPersonalAccount>
1156.      */
1157.     public function getAppPersonalAccounts(): Collection
1158.     {
1159.         return $this->appPersonalAccounts;
1160.     }
1162.     public function addAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
1163.     {
1164.         if (!$this->appPersonalAccounts->contains($appPersonalAccount)) {
1165.             $this->appPersonalAccounts->add($appPersonalAccount);
1166.             $appPersonalAccount->setOwner($this);
1167.         }
1169.         return $this;
1170.     }
1172.     public function removeAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
1173.     {
1174.         if ($this->appPersonalAccounts->removeElement($appPersonalAccount)) {
1175.             // set the owning side to null (unless already changed)
1176.             if ($appPersonalAccount->getOwner() === $this) {
1177.                 $appPersonalAccount->setOwner(null);
1178.             }
1179.         }
1181.         return $this;
1182.     }
1184.     public function getDebug(): ?int
1185.     {
1186.         return $this->debug;
1187.     }
1189.     public function setDebug(?int $debug): static
1190.     {
1191.         $this->debug = $debug;
1193.         return $this;
1194.     }
1196.     /**
1197.      * @return Collection<int, Notification>
1198.      */
1199.     public function getNotifications(): Collection
1200.     {
1201.         return $this->notifications;
1202.     }
1204.     public function addNotification(Notification $notification): static
1205.     {
1206.         if (!$this->notifications->contains($notification)) {
1207.             $this->notifications->add($notification);
1208.             $notification->setUsers($this);
1209.         }
1211.         return $this;
1212.     }
1214.     public function removeNotification(Notification $notification): static
1215.     {
1216.         if ($this->notifications->removeElement($notification)) {
1217.             // set the owning side to null (unless already changed)
1218.             if ($notification->getUsers() === $this) {
1219.                 $notification->setUsers(null);
1220.             }
1221.         }
1223.         return $this;
1224.     }
1226.     public function isDev(): ?bool
1227.     {
1228.         return $this->dev;
1229.     }
1231.     public function setDev(?bool $dev): static
1232.     {
1233.         $this->dev = $dev;
1235.         return $this;
1236.     }
1238.     public function getDateEntered(): ?\DateTimeInterface
1239.     {
1240.         return $this->dateEntered;
1241.     }
1243.     public function setDateEntered(?\DateTimeInterface $dateEntered): static
1244.     {
1245.         $this->dateEntered = $dateEntered;
1247.         return $this;
1248.     }
1250.     /**
1251.      * @return Collection<int, MassiveNotification>
1252.      */
1253.     public function getMassiveNotifications(): Collection
1254.     {
1255.         return $this->massiveNotifications;
1256.     }
1258.     public function addMassiveNotification(MassiveNotification $massiveNotification): static
1259.     {
1260.         if (!$this->massiveNotifications->contains($massiveNotification)) {
1261.             $this->massiveNotifications->add($massiveNotification);
1262.             $massiveNotification->setUserCreated($this);
1263.         }
1265.         return $this;
1266.     }
1268.     public function removeMassiveNotification(MassiveNotification $massiveNotification): static
1269.     {
1270.         if ($this->massiveNotifications->removeElement($massiveNotification)) {
1271.             // set the owning side to null (unless already changed)
1272.             if ($massiveNotification->getUserCreated() === $this) {
1273.                 $massiveNotification->setUserCreated(null);
1274.             }
1275.         }
1277.         return $this;
1278.     }
1280. }