src/Entity/User.php line 74

Open in your IDE?
  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 Delete(
  37.             security: "object == user",
  38.             securityMessage: "Ви можете видалити лише власний обліковий запис."
  39.         ),
  40.         new Put(processor: UserPasswordHasher::class),
  41.         new Patch(processor: UserPasswordHasher::class),
  42.         new Post(
  43.             name: 'me', 
  44.             uriTemplate: '/users/me', 
  45.             controller: UserController::class
  46.         ),
  47.         new Get(
  48.             name: 'user_search', 
  49.             uriTemplate: '/user/search', 
  50.             controller: UserController::class
  51.         )
  52.     ],
  53.     normalizationContext: ['groups' => ['user:read']],
  54.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
  56. )]
  57. #[ORM\Entity(repositoryClass: UserRepository::class)]
  58. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  59. #[ApiFilter(CustomOrFilter::class,properties: [
  60.     'username' => 'ipartial', 
  61.     'firstName' => 'ipartial', 
  62.     'lastName' => 'ipartial',
  63.     'codeUser' => 'exact',
  64.     'codeManager' => 'exact',
  65. ])]
  67. #[ApiFilter(SearchFilter::class, properties: [
  69.     'accounts.manager.id' => 'exact',
  70.     'userType' => 'exact',
  71.     'appPersonalAccounts.number' => 'exact',
  72. ])]
  74. class User implements UserInterface, PasswordAuthenticatedUserInterface
  75. {
  76.     #[ORM\Id]
  77.     #[ORM\GeneratedValue]
  78.     #[ORM\Column]
  79.     #[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'])]
  80.     private ?int $id = null;
  82.     #[ORM\Column(length: 180, unique: true)]
  83.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'Notification:read', 'MassiveNotification:read'])]
  84.     private ?string $username = null;
  86.     #[Groups(['user:read', 'user:update'])]
  87.     #[ORM\Column]
  88.     private array $roles = [];
  90.     /**
  91.      * @var string The hashed password
  92.      */
  93.     #[ORM\Column]
  94.     private ?string $password = null;
  96.     #[Assert\NotBlank(groups: ['user:create'])]
  97.     #[Groups(['user:create', 'user:update'])]
  98.     private ?string $plainPassword = null;
  101.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'firstName')]
  102.     private ?self $manager = 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 $firstName  = null;
  108.     #[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'])]
  109.     #[ORM\Column(length: 255, nullable: true)]
  110.     private ?string $lastName = null;
  112.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read', 'personalAcc:read'])]
  113.     #[ORM\Column(length: 100, nullable: true)]
  114.     private ?string $phone = null;
  116.     #[Groups(['user:read', 'user:create', 'user:update'])]
  117.     #[ORM\Column(length: 255, nullable: true)]
  118.     private ?string $address = null; 
  120.     #[Groups(['user:read', 'user:create', 'user:update'])]
  121.     #[ORM\Column(length: 50, nullable: true)]
  122.     private ?string $status = null;
  124.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'personalAcc:read'])]
  125.     #[ORM\Column(length: 255, nullable: true)]
  126.     private ?string $email = null;
  128.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  129.     #[ORM\Column(length: 255, nullable: true)]
  130.     private ?string $workSchedule = null;
  132.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  133.     #[ORM\Column(length: 255, nullable: true)]
  134.     private ?string $telegram = null;
  136.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  137.     #[ORM\Column(length: 255, nullable: true)]
  138.     private ?string $viber = null;
  140.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  141.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class, cascade:['persist', 'remove'])]
  142.     private Collection $mediaObjects;
  144.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  145.     private ?\DateTimeInterface $hashDate = null;
  147.     #[ORM\Column(length: 255, nullable: true)]
  148.     private ?string $device_id = null;
  150.     #[ORM\Column(length: 10, nullable: true)]
  151.     private ?string $activeCode = null;
  153.     #[ORM\Column(nullable: true)]
  154.     private ?bool $deleted = null;
  156.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UserToken::class, cascade:['persist', 'remove'])]
  157.     private Collection $userTokens;
  159.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: AppPersonalAccount::class, orphanRemoval: true, cascade:['persist', 'remove'])]
  160.     private Collection $appPersonalAccounts;
  162.     #[ORM\Column(nullable: true)]
  163.     private ?int $debug = null;
  165.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Notification::class, cascade:['persist', 'remove'])]
  166.     private Collection $notifications;
  168.     #[ORM\Column(nullable: true)]
  169.     private ?bool $dev = null;
  171.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  172.     private ?\DateTimeInterface $dateEntered = null;
  174.     #[ORM\OneToMany(mappedBy: 'userCreated', targetEntity: MassiveNotification::class, cascade:['persist', 'remove'])]
  175.     private Collection $massiveNotifications;
  177.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'personalAcc:read'])]
  178.     #[ORM\Column(length: 50, nullable: true, options: ['default' => 'active'])]
  179.     private ?string $notificationStatus = null;
  181.     /**
  182.      * @var Collection<int, UserRole>
  183.      */
  184.     #[Groups(['user:read', 'user:create', 'user:update'])]
  185.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UserRole::class, cascade:['persist', 'remove'])]
  186.     private Collection $userRoles;
  188.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'personalAcc:read'])]
  189.     #[ORM\Column(length: 100, nullable: true)]
  190.     private ?string $emailStatus = null;
  192.     #[ORM\Column(length: 100, nullable: true)]
  193.     private ?string $osType = null;
  196.     public function __construct()
  197.     {
  198.         $this->mediaObjects = new ArrayCollection();
  199.         $this->userTokens = new ArrayCollection();
  200.         $this->appPersonalAccounts = new ArrayCollection();
  201.         $this->notifications = new ArrayCollection();
  202.         $this->massiveNotifications = new ArrayCollection();
  203.         $this->userRoles = new ArrayCollection();
  204.     }
  206.     public function getId(): ?int
  207.     {
  208.         return $this->id;
  209.     }
  211.     /**
  212.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  213.      */
  214.     public function getUsername(): string
  215.     {
  216.         return (string) $this->username;
  217.     }
  219.     public function setUsername(string $username): self
  220.     {
  221.         $this->username = $username;
  223.         return $this;
  224.     }
  226.     /**
  227.      * A visual identifier that represents this user.
  228.      *
  229.      * @see UserInterface
  230.      */
  231.     public function getUserIdentifier(): string
  232.     {
  233.         return (string) $this->username;
  234.     }
  236.     /**
  237.      * @see UserInterface
  238.      */
  239.     public function getRoles(): array
  240.     {
  241.         $roles = [];
  242.         foreach ($this->userRoles as $userRole) {
  243.             $roles[] = $userRole->getRole()->getName();
  244.         }
  245.         return array_unique($roles);
  246.     }
  248.     public function setRoles(array $roles): self
  249.     {
  250.         $this->roles = $roles;
  252.         return $this;
  253.     }
  255.     /**
  256.      * @see PasswordAuthenticatedUserInterface
  257.      */
  258.     public function getPassword(): string
  259.     {
  260.         return $this->password;
  261.     }
  263.     public function setPassword(string $password): self
  264.     {
  265.         $this->password = $password;
  267.         return $this;
  268.     }
  270.     public function getPlainPassword(): ?string
  271.     {
  272.         return $this->plainPassword;
  273.     }
  275.     public function setPlainPassword(?string $plainPassword): self
  276.     {
  277.         $this->plainPassword = $plainPassword;
  279.         return $this;
  280.     }
  282.     /**
  283.      * Returning a salt is only needed, if you are not using a modern
  284.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  285.      *
  286.      * @see UserInterface
  287.      */
  288.     public function getSalt(): ?string
  289.     {
  290.         return null;
  291.     }
  293.     /**
  294.      * @see UserInterface
  295.      */
  296.     public function eraseCredentials()
  297.     {
  298.         // If you store any temporary, sensitive data on the user, clear it here
  299.         $this->plainPassword = null;
  300.     }
  302.     public function getManagerId(): ?self
  303.     {
  304.         return $this->manager;
  305.     }
  307.     public function setManagerId(?self $manager): self
  308.     {
  309.         $this->manager = $manager;
  311.         return $this;
  312.     }
  313.     
  314.     public function getFirstName(): ?string
  315.     {
  316.         return $this->firstName;
  317.     }
  320.     public function setFirstName(string $firstName): self
  321.     {
  322.         $this->firstName = $firstName;
  324.         return $this;
  325.     }
  327.     public function getLastName(): ?string
  328.     {
  329.         return $this->lastName;
  330.     }
  332.     public function setLastName(string $lastName): self
  333.     {
  334.         $this->lastName = $lastName;
  336.         return $this;
  337.     }
  339.     public function getPhone(): ?string
  340.     {
  341.         return $this->phone;
  342.     }
  344.     public function setPhone(?string $phone): self
  345.     {
  346.         $this->phone = $phone;
  348.         return $this;
  349.     }
  351.     public function getAddress(): ?string
  352.     {
  353.         return $this->address;
  354.     }
  356.     public function setAddress(?string $address): self
  357.     {
  358.         $this->address = $address;
  360.         return $this;
  361.     }
  363.     public function getStatus(): ?string
  364.     {
  365.         return $this->status;
  366.     }
  368.     public function setStatus(?string $status): self
  369.     {
  370.         $this->status = $status;
  372.         return $this;
  373.     }
  375.     // /**
  376.     //  * @return Collection<int, UserLikeList>
  377.     //  */
  378.     // public function getUserLikeLists(): Collection
  379.     // {
  380.     //     return $this->userLikeLists;
  381.     // }
  383.     // public function addUserLikeList(UserLikeList $userLikeList): self
  384.     // {
  385.     //     if (!$this->userLikeLists->contains($userLikeList)) {
  386.     //         $this->userLikeLists->add($userLikeList);
  387.     //         $userLikeList->setUserId($this);
  388.     //     }
  390.     //     return $this;
  391.     // }
  393.     // public function removeUserLikeList(UserLikeList $userLikeList): self
  394.     // {
  395.     //     if ($this->userLikeLists->removeElement($userLikeList)) {
  396.     //         // set the owning side to null (unless already changed)
  397.     //         if ($userLikeList->getUserId() === $this) {
  398.     //             $userLikeList->setUserId(null);
  399.     //         }
  400.     //     }
  402.     //     return $this;
  403.     // }
  405.     // /**
  406.     //  * @return Collection<int, Products>
  407.     //  */
  408.     // public function getProducts(): Collection
  409.     // {
  410.     //     return $this->products;
  411.     // }
  413.     // public function addProduct(Products $product): self
  414.     // {
  415.     //     if (!$this->products->contains($product)) {
  416.     //         $this->products->add($product);
  417.     //         $product->setModifiedUserId($this);
  418.     //     }
  420.     //     return $this;
  421.     // }
  423.     // public function removeProduct(Products $product): self
  424.     // {
  425.     //     if ($this->products->removeElement($product)) {
  426.     //         // set the owning side to null (unless already changed)
  427.     //         if ($product->getModifiedUserId() === $this) {
  428.     //             $product->setModifiedUserId(null);
  429.     //         }
  430.     //     }
  432.     //     return $this;
  433.     // }
  435.     // /**
  436.     //  * @return Collection<int, Products>
  437.     //  */
  438.     // public function getCreateProducts(): Collection
  439.     // {
  440.     //     return $this->create_products;
  441.     // }
  443.     // public function addCreateProduct(Products $createProduct): self
  444.     // {
  445.     //     if (!$this->create_products->contains($createProduct)) {
  446.     //         $this->create_products->add($createProduct);
  447.     //         $createProduct->setCreatedBy($this);
  448.     //     }
  450.     //     return $this;
  451.     // }
  453.     // public function removeCreateProduct(Products $createProduct): self
  454.     // {
  455.     //     if ($this->create_products->removeElement($createProduct)) {
  456.     //         // set the owning side to null (unless already changed)
  457.     //         if ($createProduct->getCreatedBy() === $this) {
  458.     //             $createProduct->setCreatedBy(null);
  459.     //         }
  460.     //     }
  462.     //     return $this;
  463.     // }
  465.     // /**
  466.     //  * @return Collection<int, Orders>
  467.     //  */
  468.     // public function getOrders(): Collection
  469.     // {
  470.     //     return $this->orders;
  471.     // }
  473.     // public function addOrder(Orders $order): self
  474.     // {
  475.     //     if (!$this->orders->contains($order)) {
  476.     //         $this->orders->add($order);
  477.     //         $order->setUserId($this);
  478.     //     }
  480.     //     return $this;
  481.     // }
  483.     // public function removeOrder(Orders $order): self
  484.     // {
  485.     //     if ($this->orders->removeElement($order)) {
  486.     //         // set the owning side to null (unless already changed)
  487.     //         if ($order->getUserId() === $this) {
  488.     //             $order->setUserId(null);
  489.     //         }
  490.     //     }
  492.     //     return $this;
  493.     // }
  495.     // /**
  496.     //  * @return Collection<int, Orders>
  497.     //  */
  498.     // public function getManagerOrders(): Collection
  499.     // {
  500.     //     return $this->managerOrders;
  501.     // }
  503.     // public function addManagerOrder(Orders $managerOrder): self
  504.     // {
  505.     //     if (!$this->managerOrders->contains($managerOrder)) {
  506.     //         $this->managerOrders->add($managerOrder);
  507.     //         $managerOrder->setManagerId($this);
  508.     //     }
  510.     //     return $this;
  511.     // }
  513.     // public function removeManagerOrder(Orders $managerOrder): self
  514.     // {
  515.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  516.     //         // set the owning side to null (unless already changed)
  517.     //         if ($managerOrder->getManagerId() === $this) {
  518.     //             $managerOrder->setManagerId(null);
  519.     //         }
  520.     //     }
  522.     //     return $this;
  523.     // }
  525.     public function getEmail(): ?string
  526.     {
  527.         return $this->email;
  528.     }
  530.     public function setEmail(?string $email): self
  531.     {
  532.         $this->email = $email;
  534.         return $this;
  535.     }
  537.     // /**
  538.     //  * @return Collection<int, Accounts>
  539.     //  */
  540.     // public function getAccounts(): Collection
  541.     // {
  542.     //     return $this->accounts;
  543.     // }
  545.     // public function addAccount(Accounts $account): self
  546.     // {
  547.     //     if (!$this->accounts->contains($account)) {
  548.     //         $this->accounts->add($account);
  549.     //         $account->setUserId($this);
  550.     //     }
  552.     //     return $this;
  553.     // }
  555.     // public function removeAccount(Accounts $account): self
  556.     // {
  557.     //     if ($this->accounts->removeElement($account)) {
  558.     //         // set the owning side to null (unless already changed)
  559.     //         if ($account->getUserId() === $this) {
  560.     //             $account->setUserId(null);
  561.     //         }
  562.     //     }
  564.     //     return $this;
  565.     // }
  567.     // /**
  568.     //  * @return Collection<int, LoadInvoice>
  569.     //  */
  570.     // public function getLoadInvoices(): Collection
  571.     // {
  572.     //     return $this->loadInvoices;
  573.     // }
  575.     // public function addLoadInvoice(LoadInvoice $loadInvoice): self
  576.     // {
  577.     //     if (!$this->loadInvoices->contains($loadInvoice)) {
  578.     //         $this->loadInvoices->add($loadInvoice);
  579.     //         $loadInvoice->setClient($this);
  580.     //     }
  582.     //     return $this;
  583.     // }
  585.     // public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  586.     // {
  587.     //     if ($this->loadInvoices->removeElement($loadInvoice)) {
  588.     //         // set the owning side to null (unless already changed)
  589.     //         if ($loadInvoice->getClient() === $this) {
  590.     //             $loadInvoice->setClient(null);
  591.     //         }
  592.     //     }
  594.     //     return $this;
  595.     // }
  597.     // /**
  598.     //  * @return Collection<int, Accepted>
  599.     //  */
  600.     // public function getAccepteds(): Collection
  601.     // {
  602.     //     return $this->accepteds;
  603.     // }
  605.     // public function addAccepted(Accepted $accepted): self
  606.     // {
  607.     //     if (!$this->accepteds->contains($accepted)) {
  608.     //         $this->accepteds->add($accepted);
  609.     //         $accepted->setManager($this);
  610.     //     }
  612.     //     return $this;
  613.     // }
  615.     // public function removeAccepted(Accepted $accepted): self
  616.     // {
  617.     //     if ($this->accepteds->removeElement($accepted)) {
  618.     //         // set the owning side to null (unless already changed)
  619.     //         if ($accepted->getManager() === $this) {
  620.     //             $accepted->setManager(null);
  621.     //         }
  622.     //     }
  624.     //     return $this;
  625.     // }
  627.     // /**
  628.     //  * @return Collection<int, AcceptedProduct>
  629.     //  */
  630.     // public function getN(): Collection
  631.     // {
  632.     //     return $this->n;
  633.     // }
  635.     // public function addN(AcceptedProduct $n): self
  636.     // {
  637.     //     if (!$this->n->contains($n)) {
  638.     //         $this->n->add($n);
  639.     //         $n->setModifiedUser($this);
  640.     //     }
  642.     //     return $this;
  643.     // }
  645.     // public function removeN(AcceptedProduct $n): self
  646.     // {
  647.     //     if ($this->n->removeElement($n)) {
  648.     //         // set the owning side to null (unless already changed)
  649.     //         if ($n->getModifiedUser() === $this) {
  650.     //             $n->setModifiedUser(null);
  651.     //         }
  652.     //     }
  654.     //     return $this;
  655.     // }
  657.     // public function getCodeUser(): ?string
  658.     // {
  659.     //     return $this->codeUser;
  660.     // }
  662.     // public function setCodeUser(string $codeUser): self
  663.     // {
  664.     //     $this->codeUser = $codeUser;
  666.     //     return $this;
  667.     // }
  669.     // public function getCodeManager(): ?string
  670.     // {
  671.     //     return $this->codeManager;
  672.     // }
  674.     // public function setCodeManager(string $codeManager): self
  675.     // {
  676.     //     $this->codeManager = $codeManager;
  678.     //     return $this;
  679.     // }
  681.     // /**
  682.     //  * @return Collection<int, Accounts>
  683.     //  */
  684.     // public function getManagerAccounts(): Collection
  685.     // {
  686.     //     return $this->managerAccounts;
  687.     // }
  689.     // public function addManagerAccount(Accounts $managerAccount): self
  690.     // {
  691.     //     if (!$this->managerAccounts->contains($managerAccount)) {
  692.     //         $this->managerAccounts->add($managerAccount);
  693.     //         $managerAccount->setManager($this);
  694.     //     }
  696.     //     return $this;
  697.     // }
  699.     // public function removeManagerAccount(Accounts $managerAccount): self
  700.     // {
  701.     //     if ($this->managerAccounts->removeElement($managerAccount)) {
  702.     //         // set the owning side to null (unless already changed)
  703.     //         if ($managerAccount->getManager() === $this) {
  704.     //             $managerAccount->setManager(null);
  705.     //         }
  706.     //     }
  708.     //     return $this;
  709.     // }
  711.     // /**
  712.     //  * @return Collection<int, PreOrder>
  713.     //  */
  714.     // public function getPreOrders(): Collection
  715.     // {
  716.     //     return $this->preOrders;
  717.     // }
  719.     // public function addPreOrder(PreOrder $preOrder): self
  720.     // {
  721.     //     if (!$this->preOrders->contains($preOrder)) {
  722.     //         $this->preOrders->add($preOrder);
  723.     //         $preOrder->setClient($this);
  724.     //     }
  726.     //     return $this;
  727.     // }
  729.     // public function removePreOrder(PreOrder $preOrder): self
  730.     // {
  731.     //     if ($this->preOrders->removeElement($preOrder)) {
  732.     //         // set the owning side to null (unless already changed)
  733.     //         if ($preOrder->getClient() === $this) {
  734.     //             $preOrder->setClient(null);
  735.     //         }
  736.     //     }
  738.     //     return $this;
  739.     // }
  741.     // /**
  742.     //  * @return Collection<int, PreOrder>
  743.     //  */
  744.     // public function getManagerPreOrders(): Collection
  745.     // {
  746.     //     return $this->ManagerPreOrders;
  747.     // }
  749.     // public function addManagerPreOrder(PreOrder $managerPreOrder): self
  750.     // {
  751.     //     if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  752.     //         $this->ManagerPreOrders->add($managerPreOrder);
  753.     //         $managerPreOrder->setManager($this);
  754.     //     }
  756.     //     return $this;
  757.     // }
  759.     // public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  760.     // {
  761.     //     if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  762.     //         // set the owning side to null (unless already changed)
  763.     //         if ($managerPreOrder->getManager() === $this) {
  764.     //             $managerPreOrder->setManager(null);
  765.     //         }
  766.     //     }
  768.     //     return $this;
  769.     // }
  771.     // public function getWorkSchedule(): ?string
  772.     // {
  773.     //     return $this->workSchedule;
  774.     // }
  776.     // public function setWorkSchedule(?string $workSchedule): self
  777.     // {
  778.     //     $this->workSchedule = $workSchedule;
  780.     //     return $this;
  781.     // }
  783.     // public function getTelegram(): ?string
  784.     // {
  785.     //     return $this->telegram;
  786.     // }
  788.     // public function setTelegram(?string $telegram): self
  789.     // {
  790.     //     $this->telegram = $telegram;
  792.     //     return $this;
  793.     // }
  795.     // public function getViber(): ?string
  796.     // {
  797.     //     return $this->viber;
  798.     // }
  800.     // public function setViber(?string $viber): self
  801.     // {
  802.     //     $this->viber = $viber;
  804.     //     return $this;
  805.     // }
  807.     /**
  808.      * @return Collection<int, MediaObject>
  809.      */
  810.     public function getMediaObjects(): Collection
  811.     {
  812.         return $this->mediaObjects;
  813.     }
  815.     public function addMediaObject(MediaObject $mediaObject): self
  816.     {
  817.         if (!$this->mediaObjects->contains($mediaObject)) {
  818.             $this->mediaObjects->add($mediaObject);
  819.             $mediaObject->setUsers($this);
  820.         }
  822.         return $this;
  823.     }
  825.     public function removeMediaObject(MediaObject $mediaObject): self
  826.     {
  827.         if ($this->mediaObjects->removeElement($mediaObject)) {
  828.             // set the owning side to null (unless already changed)
  829.             if ($mediaObject->getUsers() === $this) {
  830.                 $mediaObject->setUsers(null);
  831.             }
  832.         }
  834.         return $this;
  835.     }
  837.     // /**
  838.     //  * @return Collection<int, Coupons>
  839.     //  */
  840.     // public function getCoupons(): Collection
  841.     // {
  842.     //     return $this->coupons;
  843.     // }
  845.     // public function addCoupon(Coupons $coupon): self
  846.     // {
  847.     //     if (!$this->coupons->contains($coupon)) {
  848.     //         $this->coupons->add($coupon);
  849.     //         $coupon->addUser($this);
  850.     //     }
  852.     //     return $this;
  853.     // }
  855.     // public function removeCoupon(Coupons $coupon): self
  856.     // {
  857.     //     if ($this->coupons->removeElement($coupon)) {
  858.     //         $coupon->removeUser($this);
  859.     //     }
  861.     //     return $this;
  862.     // }
  864.     // /**
  865.     //  * @return Collection<int, ProductBalanceInStorage>
  866.     //  */
  867.     // public function getProductBalanceInStorages(): Collection
  868.     // {
  869.     //     return $this->productBalanceInStorages;
  870.     // }
  872.     // public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  873.     // {
  874.     //     if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  875.     //         $this->productBalanceInStorages->add($productBalanceInStorage);
  876.     //         $productBalanceInStorage->setManager($this);
  877.     //     }
  879.     //     return $this;
  880.     // }
  882.     // public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  883.     // {
  884.     //     if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  885.     //         // set the owning side to null (unless already changed)
  886.     //         if ($productBalanceInStorage->getManager() === $this) {
  887.     //             $productBalanceInStorage->setManager(null);
  888.     //         }
  889.     //     }
  891.     //     return $this;
  892.     // }
  894.     // public function getEmployed(): ?string
  895.     // {
  896.     //     return $this->employed;
  897.     // }
  899.     // public function setEmployed(?string $employed): static
  900.     // {
  901.     //     $this->employed = $employed;
  903.     //     return $this;
  904.     // }
  906.     // public function getAge(): ?string
  907.     // {
  908.     //     return $this->age;
  909.     // }
  911.     // public function setAge(?string $age): static
  912.     // {
  913.     //     $this->age = $age;
  915.     //     return $this;
  916.     // }
  918.     // public function getExDirector(): ?string
  919.     // {
  920.     //     return $this->exDirector;
  921.     // }
  923.     // public function setExDirector(?string $exDirector): static
  924.     // {
  925.     //     $this->exDirector = $exDirector;
  927.     //     return $this;
  928.     // }
  930.     // public function getCurrentDirector(): ?string
  931.     // {
  932.     //     return $this->currentDirector;
  933.     // }
  935.     // public function setCurrentDirector(?string $currentDirector): static
  936.     // {
  937.     //     $this->currentDirector = $currentDirector;
  939.     //     return $this;
  940.     // }
  942.     // public function getGender(): ?string
  943.     // {
  944.     //     return $this->gender;
  945.     // }
  947.     // public function setGender(?string $gender): static
  948.     // {
  949.     //     $this->gender = $gender;
  951.     //     return $this;
  952.     // }
  954.     // public function getSupportType(): array
  955.     // {
  956.     //     return $this->supportType;
  957.     // }
  959.     // public function setSupportType(?array $supportType): static
  960.     // {
  961.     //     $this->supportType = $supportType;
  963.     //     return $this;
  964.     // }
  966.     // public function getaddressFrom(): ?string
  967.     // {
  968.     //     return $this->addressFrom;
  969.     // }
  971.     // public function setaddressFrom(?string $addressFrom): static
  972.     // {
  973.     //     $this->addressFrom = $addressFrom;
  975.     //     return $this;
  976.     // }
  978.     // public function getAnotherProgram(): ?string
  979.     // {
  980.     //     return $this->anotherProgram;
  981.     // }
  983.     // public function setAnotherProgram(?string $anotherProgram): static
  984.     // {
  985.     //     $this->anotherProgram = $anotherProgram;
  987.     //     return $this;
  988.     // }
  990.     // public function getRegionFrom(): ?string
  991.     // {
  992.     //     return $this->regionFrom;
  993.     // }
  995.     // public function setRegionFrom(?string $regionFrom): static
  996.     // {
  997.     //     $this->regionFrom = $regionFrom;
  999.     //     return $this;
  1000.     // }
  1002.     // public function getNumberFOP(): ?string
  1003.     // {
  1004.     //     return $this->numberFOP;
  1005.     // }
  1007.     // public function setNumberFOP(?string $numberFOP): static
  1008.     // {
  1009.     //     $this->numberFOP = $numberFOP;
  1011.     //     return $this;
  1012.     // }
  1014.     // public function getCodeEDRPOU(): ?string
  1015.     // {
  1016.     //     return $this->codeEDRPOU;
  1017.     // }
  1019.     // public function setCodeEDRPOU(?string $codeEDRPOU): static
  1020.     // {
  1021.     //     $this->codeEDRPOU = $codeEDRPOU;
  1023.     //     return $this;
  1024.     // }
  1026.     // public function getGrantSupport(): ?string
  1027.     // {
  1028.     //     return $this->grantSupport;
  1029.     // }
  1031.     // public function setGrantSupport(?string $grantSupport): static
  1032.     // {
  1033.     //     $this->grantSupport = $grantSupport;
  1035.     //     return $this;
  1036.     // }
  1038.     // public function getCompanyName(): ?string
  1039.     // {
  1040.     //     return $this->companyName;
  1041.     // }
  1043.     // public function setCompanyName(?string $companyName): static
  1044.     // {
  1045.     //     $this->companyName = $companyName;
  1047.     //     return $this;
  1048.     // }
  1050.     // public function getUserType(): ?string
  1051.     // {
  1052.     //     return $this->userType;
  1053.     // }
  1055.     // public function setUserType(string $userType): static
  1056.     // {
  1057.     //     $this->userType = $userType;
  1059.     //     return $this;
  1060.     // }
  1062.     // public function isIsSentForPYSupport(): ?bool
  1063.     // {
  1064.     //     return $this->isSentForPYSupport;
  1065.     // }
  1067.     // public function setIsSentForPYSupport(?bool $isSentForPYSupport): static
  1068.     // {
  1069.     //     $this->isSentForPYSupport = $isSentForPYSupport;
  1071.     //     return $this;
  1072.     // }
  1074.     // public function getHash(): ?string
  1075.     // {
  1076.     //     return $this->hash;
  1077.     // }
  1079.     // public function setHash(?string $hash): static
  1080.     // {
  1081.     //     $this->hash = $hash;
  1083.     //     return $this;
  1084.     // }
  1086.     // public function isEmailVerified(): ?bool
  1087.     // {
  1088.     //     return $this->emailVerified;
  1089.     // }
  1091.     // public function setEmailVerified(?bool $emailVerified): static
  1092.     // {
  1093.     //     $this->emailVerified = $emailVerified;
  1095.     //     return $this;
  1096.     // }
  1098.     public function getHashDate(): ?\DateTimeInterface
  1099.     {
  1100.         return $this->hashDate;
  1101.     }
  1103.     public function setHashDate(?\DateTimeInterface $hashDate): static
  1104.     {
  1105.         $this->hashDate = $hashDate;
  1107.         return $this;
  1108.     }
  1110.     public function getDeviceId(): ?string
  1111.     {
  1112.         return $this->device_id;
  1113.     }
  1115.     public function setDeviceId(?string $device_id): static
  1116.     {
  1117.         $this->device_id = $device_id;
  1119.         return $this;
  1120.     }
  1122.     public function getActiveCode(): ?string
  1123.     {
  1124.         return $this->activeCode;
  1125.     }
  1127.     public function setActiveCode(?string $activeCode): static
  1128.     {
  1129.         $this->activeCode = $activeCode;
  1131.         return $this;
  1132.     }
  1134.     public function isDeleted(): ?bool
  1135.     {
  1136.         return $this->deleted;
  1137.     }
  1139.     public function setDeleted(?bool $deleted): static
  1140.     {
  1141.         $this->deleted = $deleted;
  1143.         return $this;
  1144.     }
  1146.     /**
  1147.      * @return Collection<int, UserToken>
  1148.      */
  1149.     public function getUserTokens(): Collection
  1150.     {
  1151.         return $this->userTokens;
  1152.     }
  1154.     public function addUserToken(UserToken $userToken): static
  1155.     {
  1156.         if (!$this->userTokens->contains($userToken)) {
  1157.             $this->userTokens->add($userToken);
  1158.             $userToken->setUsers($this);
  1159.         }
  1161.         return $this;
  1162.     }
  1164.     public function removeUserToken(UserToken $userToken): static
  1165.     {
  1166.         if ($this->userTokens->removeElement($userToken)) {
  1167.             // set the owning side to null (unless already changed)
  1168.             if ($userToken->getUsers() === $this) {
  1169.                 $userToken->setUsers(null);
  1170.             }
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     /**
  1177.      * @return Collection<int, AppPersonalAccount>
  1178.      */
  1179.     public function getAppPersonalAccounts(): Collection
  1180.     {
  1181.         return $this->appPersonalAccounts;
  1182.     }
  1184.     public function addAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
  1185.     {
  1186.         if (!$this->appPersonalAccounts->contains($appPersonalAccount)) {
  1187.             $this->appPersonalAccounts->add($appPersonalAccount);
  1188.             $appPersonalAccount->setOwner($this);
  1189.         }
  1191.         return $this;
  1192.     }
  1194.     public function removeAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
  1195.     {
  1196.         if ($this->appPersonalAccounts->removeElement($appPersonalAccount)) {
  1197.             // set the owning side to null (unless already changed)
  1198.             if ($appPersonalAccount->getOwner() === $this) {
  1199.                 $appPersonalAccount->setOwner(null);
  1200.             }
  1201.         }
  1203.         return $this;
  1204.     }
  1206.     public function getDebug(): ?int
  1207.     {
  1208.         return $this->debug;
  1209.     }
  1211.     public function setDebug(?int $debug): static
  1212.     {
  1213.         $this->debug = $debug;
  1215.         return $this;
  1216.     }
  1218.     /**
  1219.      * @return Collection<int, Notification>
  1220.      */
  1221.     public function getNotifications(): Collection
  1222.     {
  1223.         return $this->notifications;
  1224.     }
  1226.     public function addNotification(Notification $notification): static
  1227.     {
  1228.         if (!$this->notifications->contains($notification)) {
  1229.             $this->notifications->add($notification);
  1230.             $notification->setUsers($this);
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     public function removeNotification(Notification $notification): static
  1237.     {
  1238.         if ($this->notifications->removeElement($notification)) {
  1239.             // set the owning side to null (unless already changed)
  1240.             if ($notification->getUsers() === $this) {
  1241.                 $notification->setUsers(null);
  1242.             }
  1243.         }
  1245.         return $this;
  1246.     }
  1248.     public function isDev(): ?bool
  1249.     {
  1250.         return $this->dev;
  1251.     }
  1253.     public function setDev(?bool $dev): static
  1254.     {
  1255.         $this->dev = $dev;
  1257.         return $this;
  1258.     }
  1260.     public function getDateEntered(): ?\DateTimeInterface
  1261.     {
  1262.         return $this->dateEntered;
  1263.     }
  1265.     public function setDateEntered(?\DateTimeInterface $dateEntered): static
  1266.     {
  1267.         $this->dateEntered = $dateEntered;
  1269.         return $this;
  1270.     }
  1272.     /**
  1273.      * @return Collection<int, MassiveNotification>
  1274.      */
  1275.     public function getMassiveNotifications(): Collection
  1276.     {
  1277.         return $this->massiveNotifications;
  1278.     }
  1280.     public function addMassiveNotification(MassiveNotification $massiveNotification): static
  1281.     {
  1282.         if (!$this->massiveNotifications->contains($massiveNotification)) {
  1283.             $this->massiveNotifications->add($massiveNotification);
  1284.             $massiveNotification->setUserCreated($this);
  1285.         }
  1287.         return $this;
  1288.     }
  1290.     public function removeMassiveNotification(MassiveNotification $massiveNotification): static
  1291.     {
  1292.         if ($this->massiveNotifications->removeElement($massiveNotification)) {
  1293.             // set the owning side to null (unless already changed)
  1294.             if ($massiveNotification->getUserCreated() === $this) {
  1295.                 $massiveNotification->setUserCreated(null);
  1296.             }
  1297.         }
  1299.         return $this;
  1300.     }
  1302.     public function getNotificationStatus(): ?string
  1303.     {
  1304.         return $this->notificationStatus;
  1305.     }
  1307.     public function setNotificationStatus(?string $notificationStatus): static
  1308.     {
  1309.         $this->notificationStatus = $notificationStatus;
  1311.         return $this;
  1312.     }
  1314.     /**
  1315.      * @return Collection<int, UserRole>
  1316.      */
  1317.     public function getUserRoles(): Collection
  1318.     {
  1319.         return $this->userRoles;
  1320.     }
  1322.     public function addUserRole(UserRole $userRole): static
  1323.     {
  1324.         if (!$this->userRoles->contains($userRole)) {
  1325.             $this->userRoles->add($userRole);
  1326.             $userRole->setUsers($this);
  1327.         }
  1328.         
  1329.         return $this;
  1330.     }
  1332.     public function getEmailStatus(): ?string
  1333.     {
  1334.         return $this->emailStatus;
  1335.     }
  1337.     public function setEmailStatus(?string $emailStatus): static
  1338.     {
  1339.         $this->emailStatus = $emailStatus;
  1341.         return $this;
  1342.     }
  1344.     public function getOsType(): ?string
  1345.     {
  1346.         return $this->osType;
  1347.     }
  1349.     public function setOsType(?string $osType): static
  1350.     {
  1351.         $this->osType = $osType;
  1353.         return $this;
  1354.     }
  1356. }