src/Entity/User.php line 72

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. // use ApiPlatform\Core\Metadata\Reswource\DeprecationMetadata;
  32. #[ORM\Table(name: 'users')]
  33. #[ApiResource(
  34.     operations: [
  35.         new GetCollection(),
  36.         new Post(processor: UserPasswordHasher::class, validationContext: ['groups' => ['Default', 'user:create']]),
  37.         new Get(),
  38.         new Put(processor: UserPasswordHasher::class),
  39.         new Patch(processor: UserPasswordHasher::class),
  40.         new Post(
  41.             name: 'me', 
  42.             uriTemplate: '/users/me', 
  43.             controller: UserController::class
  44.         ),
  45.         new Get(
  46.             name: 'user_search', 
  47.             uriTemplate: '/user/search', 
  48.             controller: UserController::class
  49.         )
  50.     ],
  51.     normalizationContext: ['groups' => ['user:read']],
  52.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
  54. )]
  55. #[ORM\Entity(repositoryClass: UserRepository::class)]
  56. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  57. #[ApiFilter(CustomOrFilter::class,properties: [
  58.     'username' => 'ipartial', 
  59.     'firstName' => 'ipartial', 
  60.     'lastName' => 'ipartial',
  61.     'codeUser' => 'exact',
  62.     'codeManager' => 'exact',
  63. ])]
  65. #[ApiFilter(SearchFilter::class, properties: [
  67.     'accounts.manager.id' => 'exact',
  68.     'userType' => 'exact',
  69.     'appPersonalAccounts.number' => 'exact',
  70. ])]
  72. class User implements UserInterface, PasswordAuthenticatedUserInterface
  73. {
  74.     #[ORM\Id]
  75.     #[ORM\GeneratedValue]
  76.     #[ORM\Column]
  77.     #[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'])]
  78.     private ?int $id = null;
  80.     #[ORM\Column(length: 180, unique: true)]
  81.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  82.     private ?string $username = null;
  84.     #[Groups(['user:read', 'user:update'])]
  85.     #[ORM\Column]
  86.     private array $roles = [];
  88.     /**
  89.      * @var string The hashed password
  90.      */
  91.     #[ORM\Column]
  92.     private ?string $password = null;
  94.     #[Assert\NotBlank(groups: ['user:create'])]
  95.     #[Groups(['user:create', 'user:update'])]
  96.     private ?string $plainPassword = null;
  99.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'firstName')]
  100.     private ?self $manager = null;
  102.     #[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'])]
  103.     #[ORM\Column(length: 255, nullable: true)]
  104.     private ?string $firstName  = null;
  106.     #[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'])]
  107.     #[ORM\Column(length: 255, nullable: true)]
  108.     private ?string $lastName = null;
  110.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read', 'personalAcc:read'])]
  111.     #[ORM\Column(length: 100, nullable: true)]
  112.     private ?string $phone = null;
  114.     #[Groups(['user:read', 'user:create', 'user:update'])]
  115.     #[ORM\Column(length: 255, nullable: true)]
  116.     private ?string $address = null; 
  118.     #[Groups(['user:read', 'user:create', 'user:update'])]
  119.     #[ORM\Column(length: 50, nullable: true)]
  120.     private ?string $status = null;
  122.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLikeList::class)]
  123.     // private Collection $userLikeLists;
  125.     // #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: Products::class)]
  126.     // private Collection $products;
  128.     // #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Products::class)]
  129.     // private Collection $create_products;
  131.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: Orders::class)]
  132.     // private Collection $orders;
  134.     // #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Orders::class)]
  135.     // private Collection $managerOrders;
  137.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'personalAcc:read'])]
  138.     #[ORM\Column(length: 255, nullable: true)]
  139.     private ?string $email = null;
  141.     // #[Groups(['user:read', 'user:create', 'user:update', 'read'])]
  142.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: Accounts::class)]
  143.     // private Collection $accounts;
  145.     // #[ORM\OneToMany(mappedBy: 'client', targetEntity: LoadInvoice::class)]
  146.     // private Collection $loadInvoices;
  148.     // #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accepted::class)]
  149.     // private Collection $accepteds;
  151.     // #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  152.     // private Collection $n;
  154.     // #[ORM\Column(length: 20, nullable: true)]
  155.     // #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  156.     // private ?string $codeUser = null;
  158.     // #[ORM\Column(length: 20, nullable: true)]
  159.     // #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  160.     // private ?string $codeManager = null;
  162.     // #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accounts::class)]
  163.     // private Collection $managerAccounts;
  165.     // #[ORM\OneToMany(mappedBy: 'client', targetEntity: PreOrder::class)]
  166.     // private Collection $preOrders;
  168.     // #[ORM\OneToMany(mappedBy: 'manager', targetEntity: PreOrder::class)]
  169.     // private Collection $ManagerPreOrders;
  171.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  172.     #[ORM\Column(length: 255, nullable: true)]
  173.     private ?string $workSchedule = null;
  175.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  176.     #[ORM\Column(length: 255, nullable: true)]
  177.     private ?string $telegram = null;
  179.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  180.     #[ORM\Column(length: 255, nullable: true)]
  181.     private ?string $viber = null;
  183.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  184.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
  185.     private Collection $mediaObjects;
  187.     // #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'users')]
  188.     // private Collection $coupons;
  190.     // #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  191.     // private Collection $productBalanceInStorages;
  193.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  194.     // #[ORM\Column(length: 255, nullable: true)]
  195.     // private ?string $employed = null;
  197.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  198.     // #[ORM\Column(length: 255, nullable: true)]
  199.     // private ?string $age = null;
  201.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  202.     // #[ORM\Column(length: 255, nullable: true)]
  203.     // private ?string $exDirector = null;
  205.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  206.     // #[ORM\Column(length: 255, nullable: true)]
  207.     // private ?string $currentDirector = null;
  209.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  210.     // #[ORM\Column(length: 255, nullable: true)]
  211.     // private ?string $gender = null;
  213.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  214.     // #[ORM\Column(options: ["default" => '[]'])]
  215.     // private array $supportType = [];
  217.     //  #[Groups(['user:read', 'user:create', 'user:update'])]
  218.     // #[ORM\Column(length: 255, nullable: true)]
  219.     // private ?string $addressFrom = null;
  221.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  222.     // #[ORM\Column(length: 255, nullable: true)]
  223.     // private ?string $anotherProgram = null;
  225.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  226.     // #[ORM\Column(length: 255, nullable: true)]
  227.     // private ?string $regionFrom = null;
  229.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  230.     // #[ORM\Column(length: 255, nullable: true)]
  231.     // private ?string $numberFOP = null;
  233.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  234.     // #[ORM\Column(length: 255, nullable: true)]
  235.     // private ?string $codeEDRPOU = null;
  237.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  238.     // #[ORM\Column(length: 255, nullable: true)]
  239.     // private ?string $grantSupport = null;
  241.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  242.     // #[ORM\Column(length: 255, nullable: true)]
  243.     // private ?string $companyName = null;
  245.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  246.     // #[ORM\Column(length: 255, nullable: true)]
  247.     // private ?string $userType = null;
  249.     // #[Groups(['user:read', 'user:create', 'user:update'])]
  250.     // #[ORM\Column(nullable: true)]
  251.     // private ?bool $isSentForPYSupport = null;
  253.     // #[ORM\Column(length: 100, nullable: true)]
  254.     // private ?string $hash = null;
  256.     // #[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'])]
  257.     // #[ORM\Column(nullable: true)]
  258.     // private ?bool $emailVerified = null;
  260.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  261.     private ?\DateTimeInterface $hashDate = null;
  263.     #[ORM\Column(length: 255, nullable: true)]
  264.     private ?string $device_id = null;
  266.     #[ORM\Column(length: 10, nullable: true)]
  267.     private ?string $activeCode = null;
  269.     #[ORM\Column(nullable: true)]
  270.     private ?bool $deleted = null;
  272.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UserToken::class)]
  273.     private Collection $userTokens;
  275.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: AppPersonalAccount::class, orphanRemoval: true)]
  276.     private Collection $appPersonalAccounts;
  278.     #[ORM\Column(nullable: true)]
  279.     private ?int $debug = null;
  281.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Notification::class)]
  282.     private Collection $notifications;
  284.     #[ORM\Column(nullable: true)]
  285.     private ?bool $dev = null;
  287.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  288.     private ?\DateTimeInterface $dateEntered = null;
  292.     public function __construct()
  293.     {
  294.         // $this->userLikeLists = new ArrayCollection();
  295.         // $this->products = new ArrayCollection();
  296.         // $this->create_products = new ArrayCollection();
  297.         // $this->orders = new ArrayCollection();
  298.         // $this->managerOrders = new ArrayCollection();
  299.         // $this->accounts = new ArrayCollection();
  300.         // $this->loadInvoices = new ArrayCollection();
  301.         // $this->accepteds = new ArrayCollection();
  302.         // $this->n = new ArrayCollection();
  303.         // $this->managerAccounts = new ArrayCollection();
  304.         // $this->preOrders = new ArrayCollection();
  305.         // $this->ManagerPreOrders = new ArrayCollection();
  306.         $this->mediaObjects = new ArrayCollection();
  307.         // $this->coupons = new ArrayCollection();
  308.         // $this->productBalanceInStorages = new ArrayCollection();
  309.         $this->userTokens = new ArrayCollection();
  310.         $this->appPersonalAccounts = new ArrayCollection();
  311.         $this->notifications = new ArrayCollection();
  312.     }
  314.     public function getId(): ?int
  315.     {
  316.         return $this->id;
  317.     }
  319.     /**
  320.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  321.      */
  322.     public function getUsername(): string
  323.     {
  324.         return (string) $this->username;
  325.     }
  327.     public function setUsername(string $username): self
  328.     {
  329.         $this->username = $username;
  331.         return $this;
  332.     }
  334.     /**
  335.      * A visual identifier that represents this user.
  336.      *
  337.      * @see UserInterface
  338.      */
  339.     public function getUserIdentifier(): string
  340.     {
  341.         return (string) $this->username;
  342.     }
  344.     /**
  345.      * @see UserInterface
  346.      */
  347.     public function getRoles(): array
  348.     {
  349.         $roles = $this->roles;
  350.         // guarantee every user at least has ROLE_USER
  351.         $roles[] = 'ROLE_USER';
  353.         return array_unique($roles);
  354.     }
  356.     public function setRoles(array $roles): self
  357.     {
  358.         $this->roles = $roles;
  360.         return $this;
  361.     }
  363.     /**
  364.      * @see PasswordAuthenticatedUserInterface
  365.      */
  366.     public function getPassword(): string
  367.     {
  368.         return $this->password;
  369.     }
  371.     public function setPassword(string $password): self
  372.     {
  373.         $this->password = $password;
  375.         return $this;
  376.     }
  378.     public function getPlainPassword(): ?string
  379.     {
  380.         return $this->plainPassword;
  381.     }
  383.     public function setPlainPassword(?string $plainPassword): self
  384.     {
  385.         $this->plainPassword = $plainPassword;
  387.         return $this;
  388.     }
  390.     /**
  391.      * Returning a salt is only needed, if you are not using a modern
  392.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  393.      *
  394.      * @see UserInterface
  395.      */
  396.     public function getSalt(): ?string
  397.     {
  398.         return null;
  399.     }
  401.     /**
  402.      * @see UserInterface
  403.      */
  404.     public function eraseCredentials()
  405.     {
  406.         // If you store any temporary, sensitive data on the user, clear it here
  407.         $this->plainPassword = null;
  408.     }
  410.     public function getManagerId(): ?self
  411.     {
  412.         return $this->manager;
  413.     }
  415.     public function setManagerId(?self $manager): self
  416.     {
  417.         $this->manager = $manager;
  419.         return $this;
  420.     }
  421.     
  422.     public function getFirstName(): ?string
  423.     {
  424.         return $this->firstName;
  425.     }
  428.     public function setFirstName(string $firstName): self
  429.     {
  430.         $this->firstName = $firstName;
  432.         return $this;
  433.     }
  435.     public function getLastName(): ?string
  436.     {
  437.         return $this->lastName;
  438.     }
  440.     public function setLastName(string $lastName): self
  441.     {
  442.         $this->lastName = $lastName;
  444.         return $this;
  445.     }
  447.     public function getPhone(): ?string
  448.     {
  449.         return $this->phone;
  450.     }
  452.     public function setPhone(?string $phone): self
  453.     {
  454.         $this->phone = $phone;
  456.         return $this;
  457.     }
  459.     public function getAddress(): ?string
  460.     {
  461.         return $this->address;
  462.     }
  464.     public function setAddress(?string $address): self
  465.     {
  466.         $this->address = $address;
  468.         return $this;
  469.     }
  471.     public function getStatus(): ?string
  472.     {
  473.         return $this->status;
  474.     }
  476.     public function setStatus(?string $status): self
  477.     {
  478.         $this->status = $status;
  480.         return $this;
  481.     }
  483.     // /**
  484.     //  * @return Collection<int, UserLikeList>
  485.     //  */
  486.     // public function getUserLikeLists(): Collection
  487.     // {
  488.     //     return $this->userLikeLists;
  489.     // }
  491.     // public function addUserLikeList(UserLikeList $userLikeList): self
  492.     // {
  493.     //     if (!$this->userLikeLists->contains($userLikeList)) {
  494.     //         $this->userLikeLists->add($userLikeList);
  495.     //         $userLikeList->setUserId($this);
  496.     //     }
  498.     //     return $this;
  499.     // }
  501.     // public function removeUserLikeList(UserLikeList $userLikeList): self
  502.     // {
  503.     //     if ($this->userLikeLists->removeElement($userLikeList)) {
  504.     //         // set the owning side to null (unless already changed)
  505.     //         if ($userLikeList->getUserId() === $this) {
  506.     //             $userLikeList->setUserId(null);
  507.     //         }
  508.     //     }
  510.     //     return $this;
  511.     // }
  513.     // /**
  514.     //  * @return Collection<int, Products>
  515.     //  */
  516.     // public function getProducts(): Collection
  517.     // {
  518.     //     return $this->products;
  519.     // }
  521.     // public function addProduct(Products $product): self
  522.     // {
  523.     //     if (!$this->products->contains($product)) {
  524.     //         $this->products->add($product);
  525.     //         $product->setModifiedUserId($this);
  526.     //     }
  528.     //     return $this;
  529.     // }
  531.     // public function removeProduct(Products $product): self
  532.     // {
  533.     //     if ($this->products->removeElement($product)) {
  534.     //         // set the owning side to null (unless already changed)
  535.     //         if ($product->getModifiedUserId() === $this) {
  536.     //             $product->setModifiedUserId(null);
  537.     //         }
  538.     //     }
  540.     //     return $this;
  541.     // }
  543.     // /**
  544.     //  * @return Collection<int, Products>
  545.     //  */
  546.     // public function getCreateProducts(): Collection
  547.     // {
  548.     //     return $this->create_products;
  549.     // }
  551.     // public function addCreateProduct(Products $createProduct): self
  552.     // {
  553.     //     if (!$this->create_products->contains($createProduct)) {
  554.     //         $this->create_products->add($createProduct);
  555.     //         $createProduct->setCreatedBy($this);
  556.     //     }
  558.     //     return $this;
  559.     // }
  561.     // public function removeCreateProduct(Products $createProduct): self
  562.     // {
  563.     //     if ($this->create_products->removeElement($createProduct)) {
  564.     //         // set the owning side to null (unless already changed)
  565.     //         if ($createProduct->getCreatedBy() === $this) {
  566.     //             $createProduct->setCreatedBy(null);
  567.     //         }
  568.     //     }
  570.     //     return $this;
  571.     // }
  573.     // /**
  574.     //  * @return Collection<int, Orders>
  575.     //  */
  576.     // public function getOrders(): Collection
  577.     // {
  578.     //     return $this->orders;
  579.     // }
  581.     // public function addOrder(Orders $order): self
  582.     // {
  583.     //     if (!$this->orders->contains($order)) {
  584.     //         $this->orders->add($order);
  585.     //         $order->setUserId($this);
  586.     //     }
  588.     //     return $this;
  589.     // }
  591.     // public function removeOrder(Orders $order): self
  592.     // {
  593.     //     if ($this->orders->removeElement($order)) {
  594.     //         // set the owning side to null (unless already changed)
  595.     //         if ($order->getUserId() === $this) {
  596.     //             $order->setUserId(null);
  597.     //         }
  598.     //     }
  600.     //     return $this;
  601.     // }
  603.     // /**
  604.     //  * @return Collection<int, Orders>
  605.     //  */
  606.     // public function getManagerOrders(): Collection
  607.     // {
  608.     //     return $this->managerOrders;
  609.     // }
  611.     // public function addManagerOrder(Orders $managerOrder): self
  612.     // {
  613.     //     if (!$this->managerOrders->contains($managerOrder)) {
  614.     //         $this->managerOrders->add($managerOrder);
  615.     //         $managerOrder->setManagerId($this);
  616.     //     }
  618.     //     return $this;
  619.     // }
  621.     // public function removeManagerOrder(Orders $managerOrder): self
  622.     // {
  623.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  624.     //         // set the owning side to null (unless already changed)
  625.     //         if ($managerOrder->getManagerId() === $this) {
  626.     //             $managerOrder->setManagerId(null);
  627.     //         }
  628.     //     }
  630.     //     return $this;
  631.     // }
  633.     public function getEmail(): ?string
  634.     {
  635.         return $this->email;
  636.     }
  638.     public function setEmail(?string $email): self
  639.     {
  640.         $this->email = $email;
  642.         return $this;
  643.     }
  645.     // /**
  646.     //  * @return Collection<int, Accounts>
  647.     //  */
  648.     // public function getAccounts(): Collection
  649.     // {
  650.     //     return $this->accounts;
  651.     // }
  653.     // public function addAccount(Accounts $account): self
  654.     // {
  655.     //     if (!$this->accounts->contains($account)) {
  656.     //         $this->accounts->add($account);
  657.     //         $account->setUserId($this);
  658.     //     }
  660.     //     return $this;
  661.     // }
  663.     // public function removeAccount(Accounts $account): self
  664.     // {
  665.     //     if ($this->accounts->removeElement($account)) {
  666.     //         // set the owning side to null (unless already changed)
  667.     //         if ($account->getUserId() === $this) {
  668.     //             $account->setUserId(null);
  669.     //         }
  670.     //     }
  672.     //     return $this;
  673.     // }
  675.     // /**
  676.     //  * @return Collection<int, LoadInvoice>
  677.     //  */
  678.     // public function getLoadInvoices(): Collection
  679.     // {
  680.     //     return $this->loadInvoices;
  681.     // }
  683.     // public function addLoadInvoice(LoadInvoice $loadInvoice): self
  684.     // {
  685.     //     if (!$this->loadInvoices->contains($loadInvoice)) {
  686.     //         $this->loadInvoices->add($loadInvoice);
  687.     //         $loadInvoice->setClient($this);
  688.     //     }
  690.     //     return $this;
  691.     // }
  693.     // public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  694.     // {
  695.     //     if ($this->loadInvoices->removeElement($loadInvoice)) {
  696.     //         // set the owning side to null (unless already changed)
  697.     //         if ($loadInvoice->getClient() === $this) {
  698.     //             $loadInvoice->setClient(null);
  699.     //         }
  700.     //     }
  702.     //     return $this;
  703.     // }
  705.     // /**
  706.     //  * @return Collection<int, Accepted>
  707.     //  */
  708.     // public function getAccepteds(): Collection
  709.     // {
  710.     //     return $this->accepteds;
  711.     // }
  713.     // public function addAccepted(Accepted $accepted): self
  714.     // {
  715.     //     if (!$this->accepteds->contains($accepted)) {
  716.     //         $this->accepteds->add($accepted);
  717.     //         $accepted->setManager($this);
  718.     //     }
  720.     //     return $this;
  721.     // }
  723.     // public function removeAccepted(Accepted $accepted): self
  724.     // {
  725.     //     if ($this->accepteds->removeElement($accepted)) {
  726.     //         // set the owning side to null (unless already changed)
  727.     //         if ($accepted->getManager() === $this) {
  728.     //             $accepted->setManager(null);
  729.     //         }
  730.     //     }
  732.     //     return $this;
  733.     // }
  735.     // /**
  736.     //  * @return Collection<int, AcceptedProduct>
  737.     //  */
  738.     // public function getN(): Collection
  739.     // {
  740.     //     return $this->n;
  741.     // }
  743.     // public function addN(AcceptedProduct $n): self
  744.     // {
  745.     //     if (!$this->n->contains($n)) {
  746.     //         $this->n->add($n);
  747.     //         $n->setModifiedUser($this);
  748.     //     }
  750.     //     return $this;
  751.     // }
  753.     // public function removeN(AcceptedProduct $n): self
  754.     // {
  755.     //     if ($this->n->removeElement($n)) {
  756.     //         // set the owning side to null (unless already changed)
  757.     //         if ($n->getModifiedUser() === $this) {
  758.     //             $n->setModifiedUser(null);
  759.     //         }
  760.     //     }
  762.     //     return $this;
  763.     // }
  765.     // public function getCodeUser(): ?string
  766.     // {
  767.     //     return $this->codeUser;
  768.     // }
  770.     // public function setCodeUser(string $codeUser): self
  771.     // {
  772.     //     $this->codeUser = $codeUser;
  774.     //     return $this;
  775.     // }
  777.     // public function getCodeManager(): ?string
  778.     // {
  779.     //     return $this->codeManager;
  780.     // }
  782.     // public function setCodeManager(string $codeManager): self
  783.     // {
  784.     //     $this->codeManager = $codeManager;
  786.     //     return $this;
  787.     // }
  789.     // /**
  790.     //  * @return Collection<int, Accounts>
  791.     //  */
  792.     // public function getManagerAccounts(): Collection
  793.     // {
  794.     //     return $this->managerAccounts;
  795.     // }
  797.     // public function addManagerAccount(Accounts $managerAccount): self
  798.     // {
  799.     //     if (!$this->managerAccounts->contains($managerAccount)) {
  800.     //         $this->managerAccounts->add($managerAccount);
  801.     //         $managerAccount->setManager($this);
  802.     //     }
  804.     //     return $this;
  805.     // }
  807.     // public function removeManagerAccount(Accounts $managerAccount): self
  808.     // {
  809.     //     if ($this->managerAccounts->removeElement($managerAccount)) {
  810.     //         // set the owning side to null (unless already changed)
  811.     //         if ($managerAccount->getManager() === $this) {
  812.     //             $managerAccount->setManager(null);
  813.     //         }
  814.     //     }
  816.     //     return $this;
  817.     // }
  819.     // /**
  820.     //  * @return Collection<int, PreOrder>
  821.     //  */
  822.     // public function getPreOrders(): Collection
  823.     // {
  824.     //     return $this->preOrders;
  825.     // }
  827.     // public function addPreOrder(PreOrder $preOrder): self
  828.     // {
  829.     //     if (!$this->preOrders->contains($preOrder)) {
  830.     //         $this->preOrders->add($preOrder);
  831.     //         $preOrder->setClient($this);
  832.     //     }
  834.     //     return $this;
  835.     // }
  837.     // public function removePreOrder(PreOrder $preOrder): self
  838.     // {
  839.     //     if ($this->preOrders->removeElement($preOrder)) {
  840.     //         // set the owning side to null (unless already changed)
  841.     //         if ($preOrder->getClient() === $this) {
  842.     //             $preOrder->setClient(null);
  843.     //         }
  844.     //     }
  846.     //     return $this;
  847.     // }
  849.     // /**
  850.     //  * @return Collection<int, PreOrder>
  851.     //  */
  852.     // public function getManagerPreOrders(): Collection
  853.     // {
  854.     //     return $this->ManagerPreOrders;
  855.     // }
  857.     // public function addManagerPreOrder(PreOrder $managerPreOrder): self
  858.     // {
  859.     //     if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  860.     //         $this->ManagerPreOrders->add($managerPreOrder);
  861.     //         $managerPreOrder->setManager($this);
  862.     //     }
  864.     //     return $this;
  865.     // }
  867.     // public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  868.     // {
  869.     //     if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  870.     //         // set the owning side to null (unless already changed)
  871.     //         if ($managerPreOrder->getManager() === $this) {
  872.     //             $managerPreOrder->setManager(null);
  873.     //         }
  874.     //     }
  876.     //     return $this;
  877.     // }
  879.     // public function getWorkSchedule(): ?string
  880.     // {
  881.     //     return $this->workSchedule;
  882.     // }
  884.     // public function setWorkSchedule(?string $workSchedule): self
  885.     // {
  886.     //     $this->workSchedule = $workSchedule;
  888.     //     return $this;
  889.     // }
  891.     // public function getTelegram(): ?string
  892.     // {
  893.     //     return $this->telegram;
  894.     // }
  896.     // public function setTelegram(?string $telegram): self
  897.     // {
  898.     //     $this->telegram = $telegram;
  900.     //     return $this;
  901.     // }
  903.     // public function getViber(): ?string
  904.     // {
  905.     //     return $this->viber;
  906.     // }
  908.     // public function setViber(?string $viber): self
  909.     // {
  910.     //     $this->viber = $viber;
  912.     //     return $this;
  913.     // }
  915.     /**
  916.      * @return Collection<int, MediaObject>
  917.      */
  918.     public function getMediaObjects(): Collection
  919.     {
  920.         return $this->mediaObjects;
  921.     }
  923.     public function addMediaObject(MediaObject $mediaObject): self
  924.     {
  925.         if (!$this->mediaObjects->contains($mediaObject)) {
  926.             $this->mediaObjects->add($mediaObject);
  927.             $mediaObject->setUsers($this);
  928.         }
  930.         return $this;
  931.     }
  933.     public function removeMediaObject(MediaObject $mediaObject): self
  934.     {
  935.         if ($this->mediaObjects->removeElement($mediaObject)) {
  936.             // set the owning side to null (unless already changed)
  937.             if ($mediaObject->getUsers() === $this) {
  938.                 $mediaObject->setUsers(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  945.     // /**
  946.     //  * @return Collection<int, Coupons>
  947.     //  */
  948.     // public function getCoupons(): Collection
  949.     // {
  950.     //     return $this->coupons;
  951.     // }
  953.     // public function addCoupon(Coupons $coupon): self
  954.     // {
  955.     //     if (!$this->coupons->contains($coupon)) {
  956.     //         $this->coupons->add($coupon);
  957.     //         $coupon->addUser($this);
  958.     //     }
  960.     //     return $this;
  961.     // }
  963.     // public function removeCoupon(Coupons $coupon): self
  964.     // {
  965.     //     if ($this->coupons->removeElement($coupon)) {
  966.     //         $coupon->removeUser($this);
  967.     //     }
  969.     //     return $this;
  970.     // }
  972.     // /**
  973.     //  * @return Collection<int, ProductBalanceInStorage>
  974.     //  */
  975.     // public function getProductBalanceInStorages(): Collection
  976.     // {
  977.     //     return $this->productBalanceInStorages;
  978.     // }
  980.     // public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  981.     // {
  982.     //     if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  983.     //         $this->productBalanceInStorages->add($productBalanceInStorage);
  984.     //         $productBalanceInStorage->setManager($this);
  985.     //     }
  987.     //     return $this;
  988.     // }
  990.     // public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  991.     // {
  992.     //     if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  993.     //         // set the owning side to null (unless already changed)
  994.     //         if ($productBalanceInStorage->getManager() === $this) {
  995.     //             $productBalanceInStorage->setManager(null);
  996.     //         }
  997.     //     }
  999.     //     return $this;
  1000.     // }
  1002.     // public function getEmployed(): ?string
  1003.     // {
  1004.     //     return $this->employed;
  1005.     // }
  1007.     // public function setEmployed(?string $employed): static
  1008.     // {
  1009.     //     $this->employed = $employed;
  1011.     //     return $this;
  1012.     // }
  1014.     // public function getAge(): ?string
  1015.     // {
  1016.     //     return $this->age;
  1017.     // }
  1019.     // public function setAge(?string $age): static
  1020.     // {
  1021.     //     $this->age = $age;
  1023.     //     return $this;
  1024.     // }
  1026.     // public function getExDirector(): ?string
  1027.     // {
  1028.     //     return $this->exDirector;
  1029.     // }
  1031.     // public function setExDirector(?string $exDirector): static
  1032.     // {
  1033.     //     $this->exDirector = $exDirector;
  1035.     //     return $this;
  1036.     // }
  1038.     // public function getCurrentDirector(): ?string
  1039.     // {
  1040.     //     return $this->currentDirector;
  1041.     // }
  1043.     // public function setCurrentDirector(?string $currentDirector): static
  1044.     // {
  1045.     //     $this->currentDirector = $currentDirector;
  1047.     //     return $this;
  1048.     // }
  1050.     // public function getGender(): ?string
  1051.     // {
  1052.     //     return $this->gender;
  1053.     // }
  1055.     // public function setGender(?string $gender): static
  1056.     // {
  1057.     //     $this->gender = $gender;
  1059.     //     return $this;
  1060.     // }
  1062.     // public function getSupportType(): array
  1063.     // {
  1064.     //     return $this->supportType;
  1065.     // }
  1067.     // public function setSupportType(?array $supportType): static
  1068.     // {
  1069.     //     $this->supportType = $supportType;
  1071.     //     return $this;
  1072.     // }
  1074.     // public function getaddressFrom(): ?string
  1075.     // {
  1076.     //     return $this->addressFrom;
  1077.     // }
  1079.     // public function setaddressFrom(?string $addressFrom): static
  1080.     // {
  1081.     //     $this->addressFrom = $addressFrom;
  1083.     //     return $this;
  1084.     // }
  1086.     // public function getAnotherProgram(): ?string
  1087.     // {
  1088.     //     return $this->anotherProgram;
  1089.     // }
  1091.     // public function setAnotherProgram(?string $anotherProgram): static
  1092.     // {
  1093.     //     $this->anotherProgram = $anotherProgram;
  1095.     //     return $this;
  1096.     // }
  1098.     // public function getRegionFrom(): ?string
  1099.     // {
  1100.     //     return $this->regionFrom;
  1101.     // }
  1103.     // public function setRegionFrom(?string $regionFrom): static
  1104.     // {
  1105.     //     $this->regionFrom = $regionFrom;
  1107.     //     return $this;
  1108.     // }
  1110.     // public function getNumberFOP(): ?string
  1111.     // {
  1112.     //     return $this->numberFOP;
  1113.     // }
  1115.     // public function setNumberFOP(?string $numberFOP): static
  1116.     // {
  1117.     //     $this->numberFOP = $numberFOP;
  1119.     //     return $this;
  1120.     // }
  1122.     // public function getCodeEDRPOU(): ?string
  1123.     // {
  1124.     //     return $this->codeEDRPOU;
  1125.     // }
  1127.     // public function setCodeEDRPOU(?string $codeEDRPOU): static
  1128.     // {
  1129.     //     $this->codeEDRPOU = $codeEDRPOU;
  1131.     //     return $this;
  1132.     // }
  1134.     // public function getGrantSupport(): ?string
  1135.     // {
  1136.     //     return $this->grantSupport;
  1137.     // }
  1139.     // public function setGrantSupport(?string $grantSupport): static
  1140.     // {
  1141.     //     $this->grantSupport = $grantSupport;
  1143.     //     return $this;
  1144.     // }
  1146.     // public function getCompanyName(): ?string
  1147.     // {
  1148.     //     return $this->companyName;
  1149.     // }
  1151.     // public function setCompanyName(?string $companyName): static
  1152.     // {
  1153.     //     $this->companyName = $companyName;
  1155.     //     return $this;
  1156.     // }
  1158.     // public function getUserType(): ?string
  1159.     // {
  1160.     //     return $this->userType;
  1161.     // }
  1163.     // public function setUserType(string $userType): static
  1164.     // {
  1165.     //     $this->userType = $userType;
  1167.     //     return $this;
  1168.     // }
  1170.     // public function isIsSentForPYSupport(): ?bool
  1171.     // {
  1172.     //     return $this->isSentForPYSupport;
  1173.     // }
  1175.     // public function setIsSentForPYSupport(?bool $isSentForPYSupport): static
  1176.     // {
  1177.     //     $this->isSentForPYSupport = $isSentForPYSupport;
  1179.     //     return $this;
  1180.     // }
  1182.     // public function getHash(): ?string
  1183.     // {
  1184.     //     return $this->hash;
  1185.     // }
  1187.     // public function setHash(?string $hash): static
  1188.     // {
  1189.     //     $this->hash = $hash;
  1191.     //     return $this;
  1192.     // }
  1194.     // public function isEmailVerified(): ?bool
  1195.     // {
  1196.     //     return $this->emailVerified;
  1197.     // }
  1199.     // public function setEmailVerified(?bool $emailVerified): static
  1200.     // {
  1201.     //     $this->emailVerified = $emailVerified;
  1203.     //     return $this;
  1204.     // }
  1206.     public function getHashDate(): ?\DateTimeInterface
  1207.     {
  1208.         return $this->hashDate;
  1209.     }
  1211.     public function setHashDate(?\DateTimeInterface $hashDate): static
  1212.     {
  1213.         $this->hashDate = $hashDate;
  1215.         return $this;
  1216.     }
  1218.     public function getDeviceId(): ?string
  1219.     {
  1220.         return $this->device_id;
  1221.     }
  1223.     public function setDeviceId(?string $device_id): static
  1224.     {
  1225.         $this->device_id = $device_id;
  1227.         return $this;
  1228.     }
  1230.     public function getActiveCode(): ?string
  1231.     {
  1232.         return $this->activeCode;
  1233.     }
  1235.     public function setActiveCode(?string $activeCode): static
  1236.     {
  1237.         $this->activeCode = $activeCode;
  1239.         return $this;
  1240.     }
  1242.     public function isDeleted(): ?bool
  1243.     {
  1244.         return $this->deleted;
  1245.     }
  1247.     public function setDeleted(?bool $deleted): static
  1248.     {
  1249.         $this->deleted = $deleted;
  1251.         return $this;
  1252.     }
  1254.     /**
  1255.      * @return Collection<int, UserToken>
  1256.      */
  1257.     public function getUserTokens(): Collection
  1258.     {
  1259.         return $this->userTokens;
  1260.     }
  1262.     public function addUserToken(UserToken $userToken): static
  1263.     {
  1264.         if (!$this->userTokens->contains($userToken)) {
  1265.             $this->userTokens->add($userToken);
  1266.             $userToken->setUsers($this);
  1267.         }
  1269.         return $this;
  1270.     }
  1272.     public function removeUserToken(UserToken $userToken): static
  1273.     {
  1274.         if ($this->userTokens->removeElement($userToken)) {
  1275.             // set the owning side to null (unless already changed)
  1276.             if ($userToken->getUsers() === $this) {
  1277.                 $userToken->setUsers(null);
  1278.             }
  1279.         }
  1281.         return $this;
  1282.     }
  1284.     /**
  1285.      * @return Collection<int, AppPersonalAccount>
  1286.      */
  1287.     public function getAppPersonalAccounts(): Collection
  1288.     {
  1289.         return $this->appPersonalAccounts;
  1290.     }
  1292.     public function addAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
  1293.     {
  1294.         if (!$this->appPersonalAccounts->contains($appPersonalAccount)) {
  1295.             $this->appPersonalAccounts->add($appPersonalAccount);
  1296.             $appPersonalAccount->setOwner($this);
  1297.         }
  1299.         return $this;
  1300.     }
  1302.     public function removeAppPersonalAccount(AppPersonalAccount $appPersonalAccount): static
  1303.     {
  1304.         if ($this->appPersonalAccounts->removeElement($appPersonalAccount)) {
  1305.             // set the owning side to null (unless already changed)
  1306.             if ($appPersonalAccount->getOwner() === $this) {
  1307.                 $appPersonalAccount->setOwner(null);
  1308.             }
  1309.         }
  1311.         return $this;
  1312.     }
  1314.     public function getDebug(): ?int
  1315.     {
  1316.         return $this->debug;
  1317.     }
  1319.     public function setDebug(?int $debug): static
  1320.     {
  1321.         $this->debug = $debug;
  1323.         return $this;
  1324.     }
  1326.     /**
  1327.      * @return Collection<int, Notification>
  1328.      */
  1329.     public function getNotifications(): Collection
  1330.     {
  1331.         return $this->notifications;
  1332.     }
  1334.     public function addNotification(Notification $notification): static
  1335.     {
  1336.         if (!$this->notifications->contains($notification)) {
  1337.             $this->notifications->add($notification);
  1338.             $notification->setUsers($this);
  1339.         }
  1341.         return $this;
  1342.     }
  1344.     public function removeNotification(Notification $notification): static
  1345.     {
  1346.         if ($this->notifications->removeElement($notification)) {
  1347.             // set the owning side to null (unless already changed)
  1348.             if ($notification->getUsers() === $this) {
  1349.                 $notification->setUsers(null);
  1350.             }
  1351.         }
  1353.         return $this;
  1354.     }
  1356.     public function isDev(): ?bool
  1357.     {
  1358.         return $this->dev;
  1359.     }
  1361.     public function setDev(?bool $dev): static
  1362.     {
  1363.         $this->dev = $dev;
  1365.         return $this;
  1366.     }
  1368.     public function getDateEntered(): ?\DateTimeInterface
  1369.     {
  1370.         return $this->dateEntered;
  1371.     }
  1373.     public function setDateEntered(?\DateTimeInterface $dateEntered): static
  1374.     {
  1375.         $this->dateEntered = $dateEntered;
  1377.         return $this;
  1378.     }
  1380. }