src/Entity/User.php line 70

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; // Змініть імпорт на правильний
  28. use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
  32. // use ApiPlatform\Core\Metadata\Reswource\DeprecationMetadata;
  34. #[ORM\Table(name: 'users')]
  35. #[ApiResource(
  36.     operations: [
  37.         new GetCollection(),
  38.         new Post(processor: UserPasswordHasher::class, validationContext: ['groups' => ['Default', 'user:create']]),
  39.         new Get(),
  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 Delete()
  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: [
  64.     'accounts.manager.id' => 'exact',
  65. ])]
  67. #[ApiFilter(OrderFilter::class, properties: ['loginCount', 'lastLogin'], arguments: ['orderParameterName' => 'order'])]
  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',  'user_docs:read', 'product:read'])]
  76.     private ?int $id = null;
  78.     #[ORM\Column(length: 180, unique: true)]
  79.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'user_docs: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.     #[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', 'product:read'])]
  98.     #[ORM\Column(length: 255, nullable: true)]
  99.     private ?string $firstName  = null;
  101.     #[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', 'product:read'])]
  102.     #[ORM\Column(length: 255, nullable: true)]
  103.     private ?string $lastName = null;
  105.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  106.     #[ORM\Column(length: 100, nullable: true)]
  107.     private ?string $phone = null;
  109.     #[Groups(['user:read', 'user:create', 'user:update'])]
  110.     #[ORM\Column(length: 255, nullable: true)]
  111.     private ?string $address = null; 
  113.     #[Groups(['user:read', 'user:create', 'user:update'])]
  114.     #[ORM\Column(length: 50, nullable: true)]
  115.     private ?string $status = null;
  117.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLikeList::class)]
  118.     private Collection $userLikeLists;
  120.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: Products::class)]
  121.     private Collection $products;
  123.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Products::class)]
  124.     private Collection $create_products;
  126.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Orders::class)]
  127.     private Collection $orders;
  129.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Orders::class)]
  130.     private Collection $managerOrders;
  132.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  133.     #[ORM\Column(length: 255, nullable: true)]
  134.     private ?string $email = null;
  136.     #[Groups(['user:read', 'user:create', 'user:update', 'read'])]
  137.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Accounts::class)]
  138.     private Collection $accounts;
  140.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: LoadInvoice::class)]
  141.     private Collection $loadInvoices;
  143.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accepted::class)]
  144.     private Collection $acceptedsManager;
  145.  
  146.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Accepted::class)]
  147.     private Collection $acceptedsClients;
  149.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  150.     private Collection $n;
  152.     #[ORM\Column(length: 20, nullable: true)]
  153.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  154.     private ?string $codeUser = null;
  156.     #[ORM\Column(length: 20, nullable: true)]
  157.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  158.     private ?string $codeManager = null;
  160.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accounts::class)]
  161.     private Collection $managerAccounts;
  163.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: PreOrder::class)]
  164.     private Collection $preOrders;
  166.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: PreOrder::class)]
  167.     private Collection $ManagerPreOrders;
  169.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  170.     #[ORM\Column(length: 255, nullable: true)]
  171.     private ?string $workSchedule = null;
  173.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  174.     #[ORM\Column(length: 255, nullable: true)]
  175.     private ?string $telegram = null;
  177.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  178.     #[ORM\Column(length: 255, nullable: true)]
  179.     private ?string $viber = null;
  181.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  182.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
  183.     private Collection $mediaObjects;
  185.     #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'users')]
  186.     private Collection $coupons;
  188.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UsersDocs::class)]
  189.     private Collection $usersDocs;
  190.     
  191.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  192.     private Collection $productBalanceInStorages;
  194.     #[Groups(['user:read', 'user:create', 'user:update'])]
  195.     #[ORM\ManyToOne(inversedBy: 'users')]
  196.     private ?Location $location = null;
  198.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Comments::class)]
  199.     private Collection $comments;
  201.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Faq::class)]
  202.     private Collection $faqs;
  204.     #[ORM\OneToMany(mappedBy: 'modifiedUser', targetEntity: Faq::class)]
  205.     private Collection $modifiedFaq;
  207.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  208.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  209.     private ?\DateTimeInterface $lastLogin = null;
  211.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  212.     #[ORM\Column(nullable: true, options: ["default" => 0])]
  213.     private ?int $loginCount = null;
  215.     #[ORM\Column(length: 100, nullable: true)]
  216.     private ?string $actionToken = null;
  218.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  219.     private ?\DateTimeInterface $actionTime = null;
  225.     public function __construct()
  226.     {
  227.         $this->userLikeLists = new ArrayCollection();
  228.         $this->products = new ArrayCollection();
  229.         $this->create_products = new ArrayCollection();
  230.         $this->orders = new ArrayCollection();
  231.         $this->managerOrders = new ArrayCollection();
  232.         $this->accounts = new ArrayCollection();
  233.         $this->loadInvoices = new ArrayCollection();
  234.         $this->acceptedsManager = new ArrayCollection();
  235.         $this->acceptedsClients = new ArrayCollection();
  236.         $this->n = new ArrayCollection();
  237.         $this->managerAccounts = new ArrayCollection();
  238.         $this->preOrders = new ArrayCollection();
  239.         $this->ManagerPreOrders = new ArrayCollection();
  240.         $this->mediaObjects = new ArrayCollection();
  241.         $this->coupons = new ArrayCollection();
  242.         $this->usersDocs = new ArrayCollection();
  243.         $this->productBalanceInStorages = new ArrayCollection();
  244.         $this->comments = new ArrayCollection();
  245.         $this->faqs = new ArrayCollection();
  246.         $this->modifiedFaq = new ArrayCollection();
  247.     }
  249.     public function getId(): ?int
  250.     {
  251.         return $this->id;
  252.     }
  254.     /**
  255.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  256.      */
  257.     public function getUsername(): string
  258.     {
  259.         return (string) $this->username;
  260.     }
  262.     public function setUsername(string $username): self
  263.     {
  264.         $this->username = $username;
  266.         return $this;
  267.     }
  269.     /**
  270.      * A visual identifier that represents this user.
  271.      *
  272.      * @see UserInterface
  273.      */
  274.     public function getUserIdentifier(): string
  275.     {
  276.         return (string) $this->username;
  277.     }
  279.     /**
  280.      * @see UserInterface
  281.      */
  282.     public function getRoles(): array
  283.     {
  284.         $roles = $this->roles;
  285.         // guarantee every user at least has ROLE_USER
  286.         $roles[] = 'ROLE_USER';
  288.         return array_unique($roles);
  289.     }
  291.     public function setRoles(array $roles): self
  292.     {
  293.         $this->roles = $roles;
  295.         return $this;
  296.     }
  298.     /**
  299.      * @see PasswordAuthenticatedUserInterface
  300.      */
  301.     public function getPassword(): string
  302.     {
  303.         return $this->password;
  304.     }
  306.     public function setPassword(string $password): self
  307.     {
  308.         $this->password = $password;
  310.         return $this;
  311.     }
  313.     public function getPlainPassword(): ?string
  314.     {
  315.         return $this->plainPassword;
  316.     }
  318.     public function setPlainPassword(?string $plainPassword): self
  319.     {
  320.         $this->plainPassword = $plainPassword;
  322.         return $this;
  323.     }
  325.     /**
  326.      * Returning a salt is only needed, if you are not using a modern
  327.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  328.      *
  329.      * @see UserInterface
  330.      */
  331.     public function getSalt(): ?string
  332.     {
  333.         return null;
  334.     }
  336.     /**
  337.      * @see UserInterface
  338.      */
  339.     public function eraseCredentials()
  340.     {
  341.         // If you store any temporary, sensitive data on the user, clear it here
  342.         $this->plainPassword = null;
  343.     }
  345.     public function getFirstName(): ?string
  346.     {
  347.         return $this->firstName;
  348.     }
  351.     public function setFirstName(string $firstName): self
  352.     {
  353.         $this->firstName = $firstName;
  355.         return $this;
  356.     }
  358.     public function getLastName(): ?string
  359.     {
  360.         return $this->lastName;
  361.     }
  363.     public function setLastName(string $lastName): self
  364.     {
  365.         $this->lastName = $lastName;
  367.         return $this;
  368.     }
  370.     public function getPhone(): ?string
  371.     {
  372.         return $this->phone;
  373.     }
  375.     public function setPhone(?string $phone): self
  376.     {
  377.         $this->phone = $phone;
  379.         return $this;
  380.     }
  382.     public function getAddress(): ?string
  383.     {
  384.         return $this->address;
  385.     }
  387.     public function setAddress(?string $address): self
  388.     {
  389.         $this->address = $address;
  391.         return $this;
  392.     }
  394.     public function getStatus(): ?string
  395.     {
  396.         return $this->status;
  397.     }
  399.     public function setStatus(?string $status): self
  400.     {
  401.         $this->status = $status;
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return Collection<int, UserLikeList>
  408.      */
  409.     public function getUserLikeLists(): Collection
  410.     {
  411.         return $this->userLikeLists;
  412.     }
  414.     public function addUserLikeList(UserLikeList $userLikeList): self
  415.     {
  416.         if (!$this->userLikeLists->contains($userLikeList)) {
  417.             $this->userLikeLists->add($userLikeList);
  418.             $userLikeList->setUserId($this);
  419.         }
  421.         return $this;
  422.     }
  424.     public function removeUserLikeList(UserLikeList $userLikeList): self
  425.     {
  426.         if ($this->userLikeLists->removeElement($userLikeList)) {
  427.             // set the owning side to null (unless already changed)
  428.             if ($userLikeList->getUserId() === $this) {
  429.                 $userLikeList->setUserId(null);
  430.             }
  431.         }
  433.         return $this;
  434.     }
  436.     /**
  437.      * @return Collection<int, Products>
  438.      */
  439.     public function getProducts(): Collection
  440.     {
  441.         return $this->products;
  442.     }
  444.     public function addProduct(Products $product): self
  445.     {
  446.         if (!$this->products->contains($product)) {
  447.             $this->products->add($product);
  448.             $product->setModifiedUserId($this);
  449.         }
  451.         return $this;
  452.     }
  454.     // public function removeProduct(Products $product): self
  455.     // {
  456.     //     if ($this->products->removeElement($product)) {
  457.     //         // set the owning side to null (unless already changed)
  458.     //         if ($product->getModifiedUserId() === $this) {
  459.     //             $product->setModifiedUserId(null);
  460.     //         }
  461.     //     }
  463.     //     return $this;
  464.     // }
  466.     /**
  467.      * @return Collection<int, Products>
  468.      */
  469.     public function getCreateProducts(): Collection
  470.     {
  471.         return $this->create_products;
  472.     }
  474.     public function addCreateProduct(Products $createProduct): self
  475.     {
  476.         if (!$this->create_products->contains($createProduct)) {
  477.             $this->create_products->add($createProduct);
  478.             $createProduct->setCreatedBy($this);
  479.         }
  481.         return $this;
  482.     }
  484.     // public function removeCreateProduct(Products $createProduct): self
  485.     // {
  486.     //     if ($this->create_products->removeElement($createProduct)) {
  487.     //         // set the owning side to null (unless already changed)
  488.     //         if ($createProduct->getCreatedBy() === $this) {
  489.     //             $createProduct->setCreatedBy(null);
  490.     //         }
  491.     //     }
  493.     //     return $this;
  494.     // }
  496.     /**
  497.      * @return Collection<int, Orders>
  498.      */
  499.     public function getOrders(): Collection
  500.     {
  501.         return $this->orders;
  502.     }
  504.     public function addOrder(Orders $order): self
  505.     {
  506.         if (!$this->orders->contains($order)) {
  507.             $this->orders->add($order);
  508.             $order->setUserId($this);
  509.         }
  511.         return $this;
  512.     }
  514.     // public function removeOrder(Orders $order): self
  515.     // {
  516.     //     if ($this->orders->removeElement($order)) {
  517.     //         // set the owning side to null (unless already changed)
  518.     //         if ($order->getUserId() === $this) {
  519.     //             $order->setUserId(null);
  520.     //         }
  521.     //     }
  523.     //     return $this;
  524.     // }
  526.     /**
  527.      * @return Collection<int, Orders>
  528.      */
  529.     public function getManagerOrders(): Collection
  530.     {
  531.         return $this->managerOrders;
  532.     }
  534.     public function addManagerOrder(Orders $managerOrder): self
  535.     {
  536.         if (!$this->managerOrders->contains($managerOrder)) {
  537.             $this->managerOrders->add($managerOrder);
  538.             $managerOrder->setManagerId($this);
  539.         }
  541.         return $this;
  542.     }
  544.     // public function removeManagerOrder(Orders $managerOrder): self
  545.     // {
  546.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  547.     //         // set the owning side to null (unless already changed)
  548.     //         if ($managerOrder->getManagerId() === $this) {
  549.     //             $managerOrder->setManagerId(null);
  550.     //         }
  551.     //     }
  553.     //     return $this;
  554.     // }
  556.     public function getEmail(): ?string
  557.     {
  558.         return $this->email;
  559.     }
  561.     public function setEmail(?string $email): self
  562.     {
  563.         $this->email = $email;
  565.         return $this;
  566.     }
  568.     /**
  569.      * @return Collection<int, Accounts>
  570.      */
  571.     public function getAccounts(): Collection
  572.     {
  573.         return $this->accounts;
  574.     }
  576.     public function addAccount(Accounts $account): self
  577.     {
  578.         if (!$this->accounts->contains($account)) {
  579.             $this->accounts->add($account);
  580.             $account->setUser($this);
  581.         }
  583.         return $this;
  584.     }
  586.     public function removeAccount(Accounts $account): self
  587.     {
  588.         if ($this->accounts->removeElement($account)) {
  589.             // set the owning side to null (unless already changed)
  590.             if ($account->getUser() === $this) {
  591.                 $account->setUser(null);
  592.             }
  593.         }
  595.         return $this;
  596.     }
  598.     /**
  599.      * @return Collection<int, LoadInvoice>
  600.      */
  601.     public function getLoadInvoices(): Collection
  602.     {
  603.         return $this->loadInvoices;
  604.     }
  606.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  607.     {
  608.         if (!$this->loadInvoices->contains($loadInvoice)) {
  609.             $this->loadInvoices->add($loadInvoice);
  610.             $loadInvoice->setClient($this);
  611.         }
  613.         return $this;
  614.     }
  616.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  617.     {
  618.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  619.             // set the owning side to null (unless already changed)
  620.             if ($loadInvoice->getClient() === $this) {
  621.                 $loadInvoice->setClient(null);
  622.             }
  623.         }
  625.         return $this;
  626.     }
  628.     /**
  629.      * @return Collection<int, Accepted>
  630.      * acceptedsManager
  631.         *acceptedsClients
  632.      */
  633.     public function getAcceptedsManager(): Collection
  634.     {
  635.         return $this->acceptedsManager;
  636.     }
  638.     public function addAcceptedsManager(Accepted $acceptedsManager): self
  639.     {
  640.         if (!$this->acceptedsManager->contains($acceptedsManager)) {
  641.             $this->acceptedsManager->add($acceptedsManager);
  642.             $acceptedsManager->setManager($this);
  643.         }
  645.         return $this;
  646.     }
  648.     public function removeAcceptedsManager(Accepted $acceptedsManager): self
  649.     {
  650.         if ($this->acceptedsManager->removeElement($acceptedsManager)) {
  651.             // set the owning side to null (unless already changed)
  652.             if ($acceptedsManager->getManager() === $this) {
  653.                 $acceptedsManager->setManager(null);
  654.             }
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * @return Collection<int, Accepted>
  662.      * acceptedsManager
  663.         *acceptedsClients
  664.      */
  665.     public function getAcceptedsClients(): Collection
  666.     {
  667.         return $this->acceptedsClients;
  668.     }
  670.     public function addAcceptedsClients(Accepted $acceptedsClients): self
  671.     {
  672.         if (!$this->acceptedsClients->contains($acceptedsClients)) {
  673.             $this->acceptedsClients->add($acceptedsClients);
  674.             $acceptedsClients->setManager($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeAcceptedsClients(Accepted $acceptedsClients): self
  681.     {
  682.         if ($this->acceptedsClients->removeElement($acceptedsClients)) {
  683.             // set the owning side to null (unless already changed)
  684.             if ($acceptedsClients->getManager() === $this) {
  685.                 $acceptedsClients->setManager(null);
  686.             }
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * @return Collection<int, AcceptedProduct>
  694.      */
  695.     public function getN(): Collection
  696.     {
  697.         return $this->n;
  698.     }
  700.     public function addN(AcceptedProduct $n): self
  701.     {
  702.         if (!$this->n->contains($n)) {
  703.             $this->n->add($n);
  704.             $n->setModifiedUser($this);
  705.         }
  707.         return $this;
  708.     }
  710.     public function removeN(AcceptedProduct $n): self
  711.     {
  712.         if ($this->n->removeElement($n)) {
  713.             // set the owning side to null (unless already changed)
  714.             if ($n->getModifiedUser() === $this) {
  715.                 $n->setModifiedUser(null);
  716.             }
  717.         }
  719.         return $this;
  720.     }
  722.     public function getCodeUser(): ?string
  723.     {
  724.         return $this->codeUser;
  725.     }
  727.     public function setCodeUser(string $codeUser): self
  728.     {
  729.         $this->codeUser = $codeUser;
  731.         return $this;
  732.     }
  734.     public function getCodeManager(): ?string
  735.     {
  736.         return $this->codeManager;
  737.     }
  739.     public function setCodeManager(string $codeManager): self
  740.     {
  741.         $this->codeManager = $codeManager;
  743.         return $this;
  744.     }
  746.     /**
  747.      * @return Collection<int, Accounts>
  748.      */
  749.     public function getManagerAccounts(): Collection
  750.     {
  751.         return $this->managerAccounts;
  752.     }
  754.     public function addManagerAccount(Accounts $managerAccount): self
  755.     {
  756.         if (!$this->managerAccounts->contains($managerAccount)) {
  757.             $this->managerAccounts->add($managerAccount);
  758.             $managerAccount->setManager($this);
  759.         }
  761.         return $this;
  762.     }
  764.     public function removeManagerAccount(Accounts $managerAccount): self
  765.     {
  766.         if ($this->managerAccounts->removeElement($managerAccount)) {
  767.             // set the owning side to null (unless already changed)
  768.             if ($managerAccount->getManager() === $this) {
  769.                 $managerAccount->setManager(null);
  770.             }
  771.         }
  773.         return $this;
  774.     }
  776.     /**
  777.      * @return Collection<int, PreOrder>
  778.      */
  779.     public function getPreOrders(): Collection
  780.     {
  781.         return $this->preOrders;
  782.     }
  784.     public function addPreOrder(PreOrder $preOrder): self
  785.     {
  786.         if (!$this->preOrders->contains($preOrder)) {
  787.             $this->preOrders->add($preOrder);
  788.             $preOrder->setClient($this);
  789.         }
  791.         return $this;
  792.     }
  794.     public function removePreOrder(PreOrder $preOrder): self
  795.     {
  796.         if ($this->preOrders->removeElement($preOrder)) {
  797.             // set the owning side to null (unless already changed)
  798.             if ($preOrder->getClient() === $this) {
  799.                 $preOrder->setClient(null);
  800.             }
  801.         }
  803.         return $this;
  804.     }
  806.     /**
  807.      * @return Collection<int, PreOrder>
  808.      */
  809.     public function getManagerPreOrders(): Collection
  810.     {
  811.         return $this->ManagerPreOrders;
  812.     }
  814.     public function addManagerPreOrder(PreOrder $managerPreOrder): self
  815.     {
  816.         if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  817.             $this->ManagerPreOrders->add($managerPreOrder);
  818.             $managerPreOrder->setManager($this);
  819.         }
  821.         return $this;
  822.     }
  824.     public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  825.     {
  826.         if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  827.             // set the owning side to null (unless already changed)
  828.             if ($managerPreOrder->getManager() === $this) {
  829.                 $managerPreOrder->setManager(null);
  830.             }
  831.         }
  833.         return $this;
  834.     }
  836.     public function getWorkSchedule(): ?string
  837.     {
  838.         return $this->workSchedule;
  839.     }
  841.     public function setWorkSchedule(?string $workSchedule): self
  842.     {
  843.         $this->workSchedule = $workSchedule;
  845.         return $this;
  846.     }
  848.     public function getTelegram(): ?string
  849.     {
  850.         return $this->telegram;
  851.     }
  853.     public function setTelegram(?string $telegram): self
  854.     {
  855.         $this->telegram = $telegram;
  857.         return $this;
  858.     }
  860.     public function getViber(): ?string
  861.     {
  862.         return $this->viber;
  863.     }
  865.     public function setViber(?string $viber): self
  866.     {
  867.         $this->viber = $viber;
  869.         return $this;
  870.     }
  872.     /**
  873.      * @return Collection<int, MediaObject>
  874.      */
  875.     public function getMediaObjects(): Collection
  876.     {
  877.         return $this->mediaObjects;
  878.     }
  880.     public function addMediaObject(MediaObject $mediaObject): self
  881.     {
  882.         if (!$this->mediaObjects->contains($mediaObject)) {
  883.             $this->mediaObjects->add($mediaObject);
  884.             $mediaObject->setUsers($this);
  885.         }
  887.         return $this;
  888.     }
  890.     public function removeMediaObject(MediaObject $mediaObject): self
  891.     {
  892.         if ($this->mediaObjects->removeElement($mediaObject)) {
  893.             // set the owning side to null (unless already changed)
  894.             if ($mediaObject->getUsers() === $this) {
  895.                 $mediaObject->setUsers(null);
  896.             }
  897.         }
  899.         return $this;
  900.     }
  902.     /**
  903.      * @return Collection<int, Coupons>
  904.      */
  905.     public function getCoupons(): Collection
  906.     {
  907.         return $this->coupons;
  908.     }
  910.     public function addCoupon(Coupons $coupon): self
  911.     {
  912.         if (!$this->coupons->contains($coupon)) {
  913.             $this->coupons->add($coupon);
  914.             $coupon->addUser($this);
  915.         }
  917.         return $this;
  918.     }
  920.     public function removeCoupon(Coupons $coupon): self
  921.     {
  922.         if ($this->coupons->removeElement($coupon)) {
  923.             $coupon->removeUser($this);
  924.         }
  926.         return $this;
  927.     }
  929.     /**
  930.      * @return Collection<int, UsersDocs>
  931.      */
  932.     public function getUsersDocs(): Collection
  933.     {
  934.         return $this->usersDocs;
  935.     }
  937.     public function addUsersDoc(UsersDocs $usersDoc): static
  938.     {
  939.         if (!$this->usersDocs->contains($usersDoc)) {
  940.             $this->usersDocs->add($usersDoc);
  941.             $usersDoc->setUsers($this);
  942.         }
  943.         return $this;
  944.     }
  945.     
  946.     /**
  947.      * @return Collection<int, ProductBalanceInStorage>
  948.      */
  949.     public function getProductBalanceInStorages(): Collection
  950.     {
  951.         return $this->productBalanceInStorages;
  952.     }
  954.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  955.     {
  956.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  957.             $this->productBalanceInStorages->add($productBalanceInStorage);
  958.             $productBalanceInStorage->setManager($this);
  959.         }
  961.         return $this;
  962.     }
  964.     public function removeUsersDoc(UsersDocs $usersDoc): static
  965.     {
  966.         if ($this->usersDocs->removeElement($usersDoc)) {
  967.             // set the owning side to null (unless already changed)
  968.             if ($usersDoc->getUsers() === $this) {
  969.                 $usersDoc->setUsers(null);
  970.             }
  971.         }
  972.         return $this;
  973.     }
  975.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  976.     {
  977.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  978.             // set the owning side to null (unless already changed)
  979.             if ($productBalanceInStorage->getManager() === $this) {
  980.                 $productBalanceInStorage->setManager(null);
  981.             }
  982.         }
  984.         return $this;
  985.     }
  987.     public function getLocation(): ?Location
  988.     {
  989.         return $this->location;
  990.     }
  992.     public function setLocation(?Location $location): self
  993.     {
  994.         $this->location = $location;
  996.         return $this;
  997.     }
  999.     /**
  1000.      * @return Collection<int, Comments>
  1001.      */
  1002.     public function getComments(): Collection
  1003.     {
  1004.         return $this->comments;
  1005.     }
  1007.     public function addComment(Comments $comment): static
  1008.     {
  1009.         if (!$this->comments->contains($comment)) {
  1010.             $this->comments->add($comment);
  1011.             $comment->setUsers($this);
  1012.         }
  1014.         return $this;
  1015.     }
  1017.     public function removeComment(Comments $comment): static
  1018.     {
  1019.         if ($this->comments->removeElement($comment)) {
  1020.             // set the owning side to null (unless already changed)
  1021.             if ($comment->getUsers() === $this) {
  1022.                 $comment->setUsers(null);
  1023.             }
  1024.         }
  1026.         return $this;
  1027.     }
  1029.     /**
  1030.      * @return Collection<int, Faq>
  1031.      */
  1032.     public function getFaqs(): Collection
  1033.     {
  1034.         return $this->faqs;
  1035.     }
  1037.     public function addFaq(Faq $faq): static
  1038.     {
  1039.         if (!$this->faqs->contains($faq)) {
  1040.             $this->faqs->add($faq);
  1041.             $faq->setCreatedBy($this);
  1042.         }
  1044.         return $this;
  1045.     }
  1047.     public function removeFaq(Faq $faq): static
  1048.     {
  1049.         if ($this->faqs->removeElement($faq)) {
  1050.             // set the owning side to null (unless already changed)
  1051.             if ($faq->getCreatedBy() === $this) {
  1052.                 $faq->setCreatedBy(null);
  1053.             }
  1054.         }
  1056.         return $this;
  1057.     }
  1059.     /**
  1060.      * @return Collection<int, Faq>
  1061.      */
  1062.     public function getModifiedFaq(): Collection
  1063.     {
  1064.         return $this->modifiedFaq;
  1065.     }
  1067.     public function addModifiedFaq(Faq $modifiedFaq): static
  1068.     {
  1069.         if (!$this->modifiedFaq->contains($modifiedFaq)) {
  1070.             $this->modifiedFaq->add($modifiedFaq);
  1071.             $modifiedFaq->setModifiedUser($this);
  1072.         }
  1074.         return $this;
  1075.     }
  1077.     public function removeModifiedFaq(Faq $modifiedFaq): static
  1078.     {
  1079.         if ($this->modifiedFaq->removeElement($modifiedFaq)) {
  1080.             // set the owning side to null (unless already changed)
  1081.             if ($modifiedFaq->getModifiedUser() === $this) {
  1082.                 $modifiedFaq->setModifiedUser(null);
  1083.             }
  1084.         }
  1086.         return $this;
  1087.     }
  1089.     public function getLastLogin(): ?\DateTimeInterface
  1090.     {
  1091.         return $this->lastLogin;
  1092.     }
  1094.     public function setLastLogin(?\DateTimeInterface $lastLogin): static
  1095.     {
  1096.         $this->lastLogin = $lastLogin;
  1098.         return $this;
  1099.     }
  1101.     public function getLoginCount(): ?int
  1102.     {
  1103.         return $this->loginCount;
  1104.     }
  1106.     public function setLoginCount(?int $loginCount): static
  1107.     {
  1108.         $this->loginCount = $loginCount;
  1110.         return $this;
  1111.     }
  1113.     public function getActionToken(): ?string
  1114.     {
  1115.         return $this->actionToken;
  1116.     }
  1118.     public function setActionToken(?string $actionToken): static
  1119.     {
  1120.         $this->actionToken = $actionToken;
  1122.         return $this;
  1123.     }
  1125.     public function getActionTime(): ?\DateTimeInterface
  1126.     {
  1127.         return $this->actionTime;
  1128.     }
  1130.     public function setActionTime(?\DateTimeInterface $actionTime): static
  1131.     {
  1132.         $this->actionTime = $actionTime;
  1134.         return $this;
  1135.     }
  1137. }