src/Entity/User.php line 67

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 Delete()
  46.     ],
  47.     normalizationContext: ['groups' => ['user:read']],
  48.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
  50. )]
  51. #[ORM\Entity(repositoryClass: UserRepository::class)]
  52. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  53. #[ApiFilter(CustomOrFilter::class,properties: [
  54.     'username' => 'ipartial', 
  55.     'firstName' => 'ipartial', 
  56.     'lastName' => 'ipartial',
  57.     'codeUser' => 'exact',
  58.     'codeManager' => 'exact',
  59. ])]
  61. #[ApiFilter(SearchFilter::class, properties: [
  63.     'accounts.manager.id' => 'exact',
  64.     'phone' => 'exact',
  65. ])]
  67. class User implements UserInterface, PasswordAuthenticatedUserInterface
  68. {
  69.     #[ORM\Id]
  70.     #[ORM\GeneratedValue]
  71.     #[ORM\Column]
  72.     #[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', 'comment:read'])]
  73.     private ?int $id = null;
  75.     #[ORM\Column(length: 180, unique: true)]
  76.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'user_docs:read'])]
  77.     private ?string $username = null;
  79.     #[Groups(['user:read', 'user:update'])]
  80.     #[ORM\Column]
  81.     private array $roles = [];
  83.     /**
  84.      * @var string The hashed password
  85.      */
  86.     #[ORM\Column]
  87.     private ?string $password = null;
  89.     #[Assert\NotBlank(groups: ['user:create'])]
  90.     #[Groups(['user:create', 'user:update'])]
  91.     private ?string $plainPassword = null;
  94.     #[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', 'comment:read'])]
  95.     #[ORM\Column(length: 255, nullable: true)]
  96.     private ?string $firstName  = null;
  98.     #[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', 'comment:read'])]
  99.     #[ORM\Column(length: 255, nullable: true)]
  100.     private ?string $lastName = null;
  102.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  103.     #[ORM\Column(length: 100, nullable: true)]
  104.     private ?string $phone = null;
  106.     #[Groups(['user:read', 'user:create', 'user:update'])]
  107.     #[ORM\Column(length: 255, nullable: true)]
  108.     private ?string $address = null; 
  110.     #[Groups(['user:read', 'user:create', 'user:update'])]
  111.     #[ORM\Column(length: 50, nullable: true)]
  112.     private ?string $status = null;
  114.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLikeList::class)]
  115.     private Collection $userLikeLists;
  117.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: Products::class)]
  118.     private Collection $products;
  120.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Products::class)]
  121.     private Collection $create_products;
  123.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Orders::class)]
  124.     private Collection $orders;
  126.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Orders::class)]
  127.     private Collection $managerOrders;
  129.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  130.     #[ORM\Column(length: 255, nullable: true)]
  131.     private ?string $email = null;
  133.     #[Groups(['user:read', 'user:create', 'user:update', 'read'])]
  134.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Accounts::class)]
  135.     private Collection $accounts;
  137.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: LoadInvoice::class)]
  138.     private Collection $loadInvoices;
  140.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accepted::class)]
  141.     private Collection $acceptedsManager;
  142.  
  143.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Accepted::class)]
  144.     private Collection $acceptedsClients;
  146.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  147.     private Collection $n;
  149.     #[ORM\Column(length: 20, nullable: true)]
  150.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  151.     private ?string $codeUser = null;
  153.     #[ORM\Column(length: 20, nullable: true)]
  154.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  155.     private ?string $codeManager = null;
  157.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accounts::class)]
  158.     private Collection $managerAccounts;
  160.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: PreOrder::class)]
  161.     private Collection $preOrders;
  163.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: PreOrder::class)]
  164.     private Collection $ManagerPreOrders;
  166.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  167.     #[ORM\Column(length: 255, nullable: true)]
  168.     private ?string $workSchedule = null;
  170.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  171.     #[ORM\Column(length: 255, nullable: true)]
  172.     private ?string $telegram = null;
  174.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  175.     #[ORM\Column(length: 255, nullable: true)]
  176.     private ?string $viber = null;
  178.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  179.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
  180.     private Collection $mediaObjects;
  182.     #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'users')]
  183.     private Collection $coupons;
  185.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: UsersDocs::class)]
  186.     private Collection $usersDocs;
  187.     
  188.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  189.     private Collection $productBalanceInStorages;
  191.     #[Groups(['user:read', 'user:create', 'user:update'])]
  192.     #[ORM\ManyToOne(inversedBy: 'users')]
  193.     private ?Location $location = null;
  195.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Comments::class)]
  196.     private Collection $comments;
  198.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Faq::class)]
  199.     private Collection $faqs;
  201.     #[ORM\OneToMany(mappedBy: 'modifiedUser', targetEntity: Faq::class)]
  202.     private Collection $modifiedFaq;
  204.     #[ORM\Column(length: 100, nullable: true)]
  205.     private ?string $actionToken = null;
  207.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  208.     private ?\DateTimeInterface $actionTime = null;
  212.     public function __construct()
  213.     {
  214.         $this->userLikeLists = new ArrayCollection();
  215.         $this->products = new ArrayCollection();
  216.         $this->create_products = new ArrayCollection();
  217.         $this->orders = new ArrayCollection();
  218.         $this->managerOrders = new ArrayCollection();
  219.         $this->accounts = new ArrayCollection();
  220.         $this->loadInvoices = new ArrayCollection();
  221.         $this->acceptedsManager = new ArrayCollection();
  222.         $this->acceptedsClients = new ArrayCollection();
  223.         $this->n = new ArrayCollection();
  224.         $this->managerAccounts = new ArrayCollection();
  225.         $this->preOrders = new ArrayCollection();
  226.         $this->ManagerPreOrders = new ArrayCollection();
  227.         $this->mediaObjects = new ArrayCollection();
  228.         $this->coupons = new ArrayCollection();
  229.         $this->usersDocs = new ArrayCollection();
  230.         $this->productBalanceInStorages = new ArrayCollection();
  231.         $this->comments = new ArrayCollection();
  232.         $this->faqs = new ArrayCollection();
  233.         $this->modifiedFaq = new ArrayCollection();
  234.     }
  236.     public function getId(): ?int
  237.     {
  238.         return $this->id;
  239.     }
  241.     /**
  242.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  243.      */
  244.     public function getUsername(): string
  245.     {
  246.         return (string) $this->username;
  247.     }
  249.     public function setUsername(string $username): self
  250.     {
  251.         $this->username = $username;
  253.         return $this;
  254.     }
  256.     /**
  257.      * A visual identifier that represents this user.
  258.      *
  259.      * @see UserInterface
  260.      */
  261.     public function getUserIdentifier(): string
  262.     {
  263.         return (string) $this->username;
  264.     }
  266.     /**
  267.      * @see UserInterface
  268.      */
  269.     public function getRoles(): array
  270.     {
  271.         $roles = $this->roles;
  272.         // guarantee every user at least has ROLE_USER
  273.         $roles[] = 'ROLE_USER';
  275.         return array_unique($roles);
  276.     }
  278.     public function setRoles(array $roles): self
  279.     {
  280.         $this->roles = $roles;
  282.         return $this;
  283.     }
  285.     /**
  286.      * @see PasswordAuthenticatedUserInterface
  287.      */
  288.     public function getPassword(): string
  289.     {
  290.         return $this->password;
  291.     }
  293.     public function setPassword(string $password): self
  294.     {
  295.         $this->password = $password;
  297.         return $this;
  298.     }
  300.     public function getPlainPassword(): ?string
  301.     {
  302.         return $this->plainPassword;
  303.     }
  305.     public function setPlainPassword(?string $plainPassword): self
  306.     {
  307.         $this->plainPassword = $plainPassword;
  309.         return $this;
  310.     }
  312.     /**
  313.      * Returning a salt is only needed, if you are not using a modern
  314.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  315.      *
  316.      * @see UserInterface
  317.      */
  318.     public function getSalt(): ?string
  319.     {
  320.         return null;
  321.     }
  323.     /**
  324.      * @see UserInterface
  325.      */
  326.     public function eraseCredentials()
  327.     {
  328.         // If you store any temporary, sensitive data on the user, clear it here
  329.         $this->plainPassword = null;
  330.     }
  332.     public function getFirstName(): ?string
  333.     {
  334.         return $this->firstName;
  335.     }
  338.     public function setFirstName(string $firstName): self
  339.     {
  340.         $this->firstName = $firstName;
  342.         return $this;
  343.     }
  345.     public function getLastName(): ?string
  346.     {
  347.         return $this->lastName;
  348.     }
  350.     public function setLastName(string $lastName): self
  351.     {
  352.         $this->lastName = $lastName;
  354.         return $this;
  355.     }
  357.     public function getPhone(): ?string
  358.     {
  359.         return $this->phone;
  360.     }
  362.     public function setPhone(?string $phone): self
  363.     {
  364.         $this->phone = $phone;
  366.         return $this;
  367.     }
  369.     public function getAddress(): ?string
  370.     {
  371.         return $this->address;
  372.     }
  374.     public function setAddress(?string $address): self
  375.     {
  376.         $this->address = $address;
  378.         return $this;
  379.     }
  381.     public function getStatus(): ?string
  382.     {
  383.         return $this->status;
  384.     }
  386.     public function setStatus(?string $status): self
  387.     {
  388.         $this->status = $status;
  390.         return $this;
  391.     }
  393.     /**
  394.      * @return Collection<int, UserLikeList>
  395.      */
  396.     public function getUserLikeLists(): Collection
  397.     {
  398.         return $this->userLikeLists;
  399.     }
  401.     public function addUserLikeList(UserLikeList $userLikeList): self
  402.     {
  403.         if (!$this->userLikeLists->contains($userLikeList)) {
  404.             $this->userLikeLists->add($userLikeList);
  405.             $userLikeList->setUserId($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeUserLikeList(UserLikeList $userLikeList): self
  412.     {
  413.         if ($this->userLikeLists->removeElement($userLikeList)) {
  414.             // set the owning side to null (unless already changed)
  415.             if ($userLikeList->getUserId() === $this) {
  416.                 $userLikeList->setUserId(null);
  417.             }
  418.         }
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return Collection<int, Products>
  425.      */
  426.     public function getProducts(): Collection
  427.     {
  428.         return $this->products;
  429.     }
  431.     public function addProduct(Products $product): self
  432.     {
  433.         if (!$this->products->contains($product)) {
  434.             $this->products->add($product);
  435.             $product->setModifiedUserId($this);
  436.         }
  438.         return $this;
  439.     }
  441.     // public function removeProduct(Products $product): self
  442.     // {
  443.     //     if ($this->products->removeElement($product)) {
  444.     //         // set the owning side to null (unless already changed)
  445.     //         if ($product->getModifiedUserId() === $this) {
  446.     //             $product->setModifiedUserId(null);
  447.     //         }
  448.     //     }
  450.     //     return $this;
  451.     // }
  453.     /**
  454.      * @return Collection<int, Products>
  455.      */
  456.     public function getCreateProducts(): Collection
  457.     {
  458.         return $this->create_products;
  459.     }
  461.     public function addCreateProduct(Products $createProduct): self
  462.     {
  463.         if (!$this->create_products->contains($createProduct)) {
  464.             $this->create_products->add($createProduct);
  465.             $createProduct->setCreatedBy($this);
  466.         }
  468.         return $this;
  469.     }
  471.     // public function removeCreateProduct(Products $createProduct): self
  472.     // {
  473.     //     if ($this->create_products->removeElement($createProduct)) {
  474.     //         // set the owning side to null (unless already changed)
  475.     //         if ($createProduct->getCreatedBy() === $this) {
  476.     //             $createProduct->setCreatedBy(null);
  477.     //         }
  478.     //     }
  480.     //     return $this;
  481.     // }
  483.     /**
  484.      * @return Collection<int, Orders>
  485.      */
  486.     public function getOrders(): Collection
  487.     {
  488.         return $this->orders;
  489.     }
  491.     public function addOrder(Orders $order): self
  492.     {
  493.         if (!$this->orders->contains($order)) {
  494.             $this->orders->add($order);
  495.             $order->setUserId($this);
  496.         }
  498.         return $this;
  499.     }
  501.     // public function removeOrder(Orders $order): self
  502.     // {
  503.     //     if ($this->orders->removeElement($order)) {
  504.     //         // set the owning side to null (unless already changed)
  505.     //         if ($order->getUserId() === $this) {
  506.     //             $order->setUserId(null);
  507.     //         }
  508.     //     }
  510.     //     return $this;
  511.     // }
  513.     /**
  514.      * @return Collection<int, Orders>
  515.      */
  516.     public function getManagerOrders(): Collection
  517.     {
  518.         return $this->managerOrders;
  519.     }
  521.     public function addManagerOrder(Orders $managerOrder): self
  522.     {
  523.         if (!$this->managerOrders->contains($managerOrder)) {
  524.             $this->managerOrders->add($managerOrder);
  525.             $managerOrder->setManagerId($this);
  526.         }
  528.         return $this;
  529.     }
  531.     // public function removeManagerOrder(Orders $managerOrder): self
  532.     // {
  533.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  534.     //         // set the owning side to null (unless already changed)
  535.     //         if ($managerOrder->getManagerId() === $this) {
  536.     //             $managerOrder->setManagerId(null);
  537.     //         }
  538.     //     }
  540.     //     return $this;
  541.     // }
  543.     public function getEmail(): ?string
  544.     {
  545.         return $this->email;
  546.     }
  548.     public function setEmail(?string $email): self
  549.     {
  550.         $this->email = $email;
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, Accounts>
  557.      */
  558.     public function getAccounts(): Collection
  559.     {
  560.         return $this->accounts;
  561.     }
  563.     public function addAccount(Accounts $account): self
  564.     {
  565.         if (!$this->accounts->contains($account)) {
  566.             $this->accounts->add($account);
  567.             $account->setUserId($this);
  568.         }
  570.         return $this;
  571.     }
  573.     public function removeAccount(Accounts $account): self
  574.     {
  575.         if ($this->accounts->removeElement($account)) {
  576.             // set the owning side to null (unless already changed)
  577.             if ($account->getUserId() === $this) {
  578.                 $account->setUserId(null);
  579.             }
  580.         }
  582.         return $this;
  583.     }
  585.     /**
  586.      * @return Collection<int, LoadInvoice>
  587.      */
  588.     public function getLoadInvoices(): Collection
  589.     {
  590.         return $this->loadInvoices;
  591.     }
  593.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  594.     {
  595.         if (!$this->loadInvoices->contains($loadInvoice)) {
  596.             $this->loadInvoices->add($loadInvoice);
  597.             $loadInvoice->setClient($this);
  598.         }
  600.         return $this;
  601.     }
  603.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  604.     {
  605.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  606.             // set the owning side to null (unless already changed)
  607.             if ($loadInvoice->getClient() === $this) {
  608.                 $loadInvoice->setClient(null);
  609.             }
  610.         }
  612.         return $this;
  613.     }
  615.     /**
  616.      * @return Collection<int, Accepted>
  617.      * acceptedsManager
  618.         *acceptedsClients
  619.      */
  620.     public function getAcceptedsManager(): Collection
  621.     {
  622.         return $this->acceptedsManager;
  623.     }
  625.     public function addAcceptedsManager(Accepted $acceptedsManager): self
  626.     {
  627.         if (!$this->acceptedsManager->contains($acceptedsManager)) {
  628.             $this->acceptedsManager->add($acceptedsManager);
  629.             $acceptedsManager->setManager($this);
  630.         }
  632.         return $this;
  633.     }
  635.     public function removeAcceptedsManager(Accepted $acceptedsManager): self
  636.     {
  637.         if ($this->acceptedsManager->removeElement($acceptedsManager)) {
  638.             // set the owning side to null (unless already changed)
  639.             if ($acceptedsManager->getManager() === $this) {
  640.                 $acceptedsManager->setManager(null);
  641.             }
  642.         }
  644.         return $this;
  645.     }
  647.     /**
  648.      * @return Collection<int, Accepted>
  649.      * acceptedsManager
  650.         *acceptedsClients
  651.      */
  652.     public function getAcceptedsClients(): Collection
  653.     {
  654.         return $this->acceptedsClients;
  655.     }
  657.     public function addAcceptedsClients(Accepted $acceptedsClients): self
  658.     {
  659.         if (!$this->acceptedsClients->contains($acceptedsClients)) {
  660.             $this->acceptedsClients->add($acceptedsClients);
  661.             $acceptedsClients->setManager($this);
  662.         }
  664.         return $this;
  665.     }
  667.     public function removeAcceptedsClients(Accepted $acceptedsClients): self
  668.     {
  669.         if ($this->acceptedsClients->removeElement($acceptedsClients)) {
  670.             // set the owning side to null (unless already changed)
  671.             if ($acceptedsClients->getManager() === $this) {
  672.                 $acceptedsClients->setManager(null);
  673.             }
  674.         }
  676.         return $this;
  677.     }
  679.     /**
  680.      * @return Collection<int, AcceptedProduct>
  681.      */
  682.     public function getN(): Collection
  683.     {
  684.         return $this->n;
  685.     }
  687.     public function addN(AcceptedProduct $n): self
  688.     {
  689.         if (!$this->n->contains($n)) {
  690.             $this->n->add($n);
  691.             $n->setModifiedUser($this);
  692.         }
  694.         return $this;
  695.     }
  697.     public function removeN(AcceptedProduct $n): self
  698.     {
  699.         if ($this->n->removeElement($n)) {
  700.             // set the owning side to null (unless already changed)
  701.             if ($n->getModifiedUser() === $this) {
  702.                 $n->setModifiedUser(null);
  703.             }
  704.         }
  706.         return $this;
  707.     }
  709.     public function getCodeUser(): ?string
  710.     {
  711.         return $this->codeUser;
  712.     }
  714.     public function setCodeUser(string $codeUser): self
  715.     {
  716.         $this->codeUser = $codeUser;
  718.         return $this;
  719.     }
  721.     public function getCodeManager(): ?string
  722.     {
  723.         return $this->codeManager;
  724.     }
  726.     public function setCodeManager(string $codeManager): self
  727.     {
  728.         $this->codeManager = $codeManager;
  730.         return $this;
  731.     }
  733.     /**
  734.      * @return Collection<int, Accounts>
  735.      */
  736.     public function getManagerAccounts(): Collection
  737.     {
  738.         return $this->managerAccounts;
  739.     }
  741.     public function addManagerAccount(Accounts $managerAccount): self
  742.     {
  743.         if (!$this->managerAccounts->contains($managerAccount)) {
  744.             $this->managerAccounts->add($managerAccount);
  745.             $managerAccount->setManager($this);
  746.         }
  748.         return $this;
  749.     }
  751.     public function removeManagerAccount(Accounts $managerAccount): self
  752.     {
  753.         if ($this->managerAccounts->removeElement($managerAccount)) {
  754.             // set the owning side to null (unless already changed)
  755.             if ($managerAccount->getManager() === $this) {
  756.                 $managerAccount->setManager(null);
  757.             }
  758.         }
  760.         return $this;
  761.     }
  763.     /**
  764.      * @return Collection<int, PreOrder>
  765.      */
  766.     public function getPreOrders(): Collection
  767.     {
  768.         return $this->preOrders;
  769.     }
  771.     public function addPreOrder(PreOrder $preOrder): self
  772.     {
  773.         if (!$this->preOrders->contains($preOrder)) {
  774.             $this->preOrders->add($preOrder);
  775.             $preOrder->setClient($this);
  776.         }
  778.         return $this;
  779.     }
  781.     public function removePreOrder(PreOrder $preOrder): self
  782.     {
  783.         if ($this->preOrders->removeElement($preOrder)) {
  784.             // set the owning side to null (unless already changed)
  785.             if ($preOrder->getClient() === $this) {
  786.                 $preOrder->setClient(null);
  787.             }
  788.         }
  790.         return $this;
  791.     }
  793.     /**
  794.      * @return Collection<int, PreOrder>
  795.      */
  796.     public function getManagerPreOrders(): Collection
  797.     {
  798.         return $this->ManagerPreOrders;
  799.     }
  801.     public function addManagerPreOrder(PreOrder $managerPreOrder): self
  802.     {
  803.         if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  804.             $this->ManagerPreOrders->add($managerPreOrder);
  805.             $managerPreOrder->setManager($this);
  806.         }
  808.         return $this;
  809.     }
  811.     public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  812.     {
  813.         if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  814.             // set the owning side to null (unless already changed)
  815.             if ($managerPreOrder->getManager() === $this) {
  816.                 $managerPreOrder->setManager(null);
  817.             }
  818.         }
  820.         return $this;
  821.     }
  823.     public function getWorkSchedule(): ?string
  824.     {
  825.         return $this->workSchedule;
  826.     }
  828.     public function setWorkSchedule(?string $workSchedule): self
  829.     {
  830.         $this->workSchedule = $workSchedule;
  832.         return $this;
  833.     }
  835.     public function getTelegram(): ?string
  836.     {
  837.         return $this->telegram;
  838.     }
  840.     public function setTelegram(?string $telegram): self
  841.     {
  842.         $this->telegram = $telegram;
  844.         return $this;
  845.     }
  847.     public function getViber(): ?string
  848.     {
  849.         return $this->viber;
  850.     }
  852.     public function setViber(?string $viber): self
  853.     {
  854.         $this->viber = $viber;
  856.         return $this;
  857.     }
  859.     /**
  860.      * @return Collection<int, MediaObject>
  861.      */
  862.     public function getMediaObjects(): Collection
  863.     {
  864.         return $this->mediaObjects;
  865.     }
  867.     public function addMediaObject(MediaObject $mediaObject): self
  868.     {
  869.         if (!$this->mediaObjects->contains($mediaObject)) {
  870.             $this->mediaObjects->add($mediaObject);
  871.             $mediaObject->setUsers($this);
  872.         }
  874.         return $this;
  875.     }
  877.     public function removeMediaObject(MediaObject $mediaObject): self
  878.     {
  879.         if ($this->mediaObjects->removeElement($mediaObject)) {
  880.             // set the owning side to null (unless already changed)
  881.             if ($mediaObject->getUsers() === $this) {
  882.                 $mediaObject->setUsers(null);
  883.             }
  884.         }
  886.         return $this;
  887.     }
  889.     /**
  890.      * @return Collection<int, Coupons>
  891.      */
  892.     public function getCoupons(): Collection
  893.     {
  894.         return $this->coupons;
  895.     }
  897.     public function addCoupon(Coupons $coupon): self
  898.     {
  899.         if (!$this->coupons->contains($coupon)) {
  900.             $this->coupons->add($coupon);
  901.             $coupon->addUser($this);
  902.         }
  904.         return $this;
  905.     }
  907.     public function removeCoupon(Coupons $coupon): self
  908.     {
  909.         if ($this->coupons->removeElement($coupon)) {
  910.             $coupon->removeUser($this);
  911.         }
  913.         return $this;
  914.     }
  916.     /**
  917.      * @return Collection<int, UsersDocs>
  918.      */
  919.     public function getUsersDocs(): Collection
  920.     {
  921.         return $this->usersDocs;
  922.     }
  924.     public function addUsersDoc(UsersDocs $usersDoc): static
  925.     {
  926.         if (!$this->usersDocs->contains($usersDoc)) {
  927.             $this->usersDocs->add($usersDoc);
  928.             $usersDoc->setUsers($this);
  929.         }
  930.         return $this;
  931.     }
  932.     
  933.     /**
  934.      * @return Collection<int, ProductBalanceInStorage>
  935.      */
  936.     public function getProductBalanceInStorages(): Collection
  937.     {
  938.         return $this->productBalanceInStorages;
  939.     }
  941.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  942.     {
  943.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  944.             $this->productBalanceInStorages->add($productBalanceInStorage);
  945.             $productBalanceInStorage->setManager($this);
  946.         }
  948.         return $this;
  949.     }
  951.     public function removeUsersDoc(UsersDocs $usersDoc): static
  952.     {
  953.         if ($this->usersDocs->removeElement($usersDoc)) {
  954.             // set the owning side to null (unless already changed)
  955.             if ($usersDoc->getUsers() === $this) {
  956.                 $usersDoc->setUsers(null);
  957.             }
  958.         }
  959.         return $this;
  960.     }
  962.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  963.     {
  964.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  965.             // set the owning side to null (unless already changed)
  966.             if ($productBalanceInStorage->getManager() === $this) {
  967.                 $productBalanceInStorage->setManager(null);
  968.             }
  969.         }
  971.         return $this;
  972.     }
  974.     public function getLocation(): ?Location
  975.     {
  976.         return $this->location;
  977.     }
  979.     public function setLocation(?Location $location): self
  980.     {
  981.         $this->location = $location;
  983.         return $this;
  984.     }
  986.     /**
  987.      * @return Collection<int, Comments>
  988.      */
  989.     public function getComments(): Collection
  990.     {
  991.         return $this->comments;
  992.     }
  994.     public function addComment(Comments $comment): static
  995.     {
  996.         if (!$this->comments->contains($comment)) {
  997.             $this->comments->add($comment);
  998.             $comment->setUsers($this);
  999.         }
  1001.         return $this;
  1002.     }
  1004.     public function removeComment(Comments $comment): static
  1005.     {
  1006.         if ($this->comments->removeElement($comment)) {
  1007.             // set the owning side to null (unless already changed)
  1008.             if ($comment->getUsers() === $this) {
  1009.                 $comment->setUsers(null);
  1010.             }
  1011.         }
  1013.         return $this;
  1014.     }
  1016.     /**
  1017.      * @return Collection<int, Faq>
  1018.      */
  1019.     public function getFaqs(): Collection
  1020.     {
  1021.         return $this->faqs;
  1022.     }
  1024.     public function addFaq(Faq $faq): static
  1025.     {
  1026.         if (!$this->faqs->contains($faq)) {
  1027.             $this->faqs->add($faq);
  1028.             $faq->setCreatedBy($this);
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function removeFaq(Faq $faq): static
  1035.     {
  1036.         if ($this->faqs->removeElement($faq)) {
  1037.             // set the owning side to null (unless already changed)
  1038.             if ($faq->getCreatedBy() === $this) {
  1039.                 $faq->setCreatedBy(null);
  1040.             }
  1041.         }
  1043.         return $this;
  1044.     }
  1046.     /**
  1047.      * @return Collection<int, Faq>
  1048.      */
  1049.     public function getModifiedFaq(): Collection
  1050.     {
  1051.         return $this->modifiedFaq;
  1052.     }
  1054.     public function addModifiedFaq(Faq $modifiedFaq): static
  1055.     {
  1056.         if (!$this->modifiedFaq->contains($modifiedFaq)) {
  1057.             $this->modifiedFaq->add($modifiedFaq);
  1058.             $modifiedFaq->setModifiedUser($this);
  1059.         }
  1061.         return $this;
  1062.     }
  1064.     public function removeModifiedFaq(Faq $modifiedFaq): static
  1065.     {
  1066.         if ($this->modifiedFaq->removeElement($modifiedFaq)) {
  1067.             // set the owning side to null (unless already changed)
  1068.             if ($modifiedFaq->getModifiedUser() === $this) {
  1069.                 $modifiedFaq->setModifiedUser(null);
  1070.             }
  1071.         }
  1073.         return $this;
  1074.     }
  1076.     public function getActionToken(): ?string
  1077.     {
  1078.         return $this->actionToken;
  1079.     }
  1081.     public function setActionToken(?string $actionToken): static
  1082.     {
  1083.         $this->actionToken = $actionToken;
  1085.         return $this;
  1086.     }
  1088.     public function getActionTime(): ?\DateTimeInterface
  1089.     {
  1090.         return $this->actionTime;
  1091.     }
  1093.     public function setActionTime(?\DateTimeInterface $actionTime): static
  1094.     {
  1095.         $this->actionTime = $actionTime;
  1097.         return $this;
  1098.     }
  1100. }