src/Entity/User.php line 65

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\ORM\Mapping as ORM;
  17. use App\Repository\UserRepository;
  18. use App\State\UserPasswordHasher;
  19. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  20. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  21. use Symfony\Component\Security\Core\User\UserInterface;
  22. use Symfony\Component\Serializer\Annotation\Groups;
  23. use Symfony\Component\Validator\Constraints as Assert;
  24. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  25. use App\Controller\UserController;
  26. use App\Filter\CustomOrFilter; // Змініть імпорт на правильний
  29. // use ApiPlatform\Core\Metadata\Reswource\DeprecationMetadata;
  31. #[ORM\Table(name: 'users')]
  32. #[ApiResource(
  33.     operations: [
  34.         new GetCollection(),
  35.         new Post(processor: UserPasswordHasher::class, validationContext: ['groups' => ['Default', 'user:create']]),
  36.         new Get(),
  37.         new Put(processor: UserPasswordHasher::class),
  38.         new Patch(processor: UserPasswordHasher::class),
  39.         new Post(
  40.             name: 'me', 
  41.             uriTemplate: '/users/me', 
  42.             controller: UserController::class
  43.         ),
  44.         new Delete()
  45.     ],
  46.     normalizationContext: ['groups' => ['user:read']],
  47.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
  49. )]
  50. #[ORM\Entity(repositoryClass: UserRepository::class)]
  51. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  52. #[ApiFilter(CustomOrFilter::class,properties: [
  53.     'username' => 'ipartial', 
  54.     'firstName' => 'ipartial', 
  55.     'lastName' => 'ipartial',
  56.     'codeUser' => 'exact',
  57.     'codeManager' => 'exact',
  58. ])]
  60. #[ApiFilter(SearchFilter::class, properties: [
  62.     'accounts.manager.id' => 'exact',
  63. ])]
  65. class User implements UserInterface, PasswordAuthenticatedUserInterface
  66. {
  67.     #[ORM\Id]
  68.     #[ORM\GeneratedValue]
  69.     #[ORM\Column]
  70.     #[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', 'product:read'])]
  71.     private ?int $id = null;
  73.     #[ORM\Column(length: 180, unique: true)]
  74.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  75.     private ?string $username = null;
  77.     #[Groups(['user:read', 'user:update'])]
  78.     #[ORM\Column]
  79.     private array $roles = [];
  81.     /**
  82.      * @var string The hashed password
  83.      */
  84.     #[ORM\Column]
  85.     private ?string $password = null;
  87.     #[Assert\NotBlank(groups: ['user:create'])]
  88.     #[Groups(['user:create', 'user:update'])]
  89.     private ?string $plainPassword = null;
  92.     #[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'])]
  93.     #[ORM\Column(length: 255, nullable: true)]
  94.     private ?string $firstName  = null;
  96.     #[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'])]
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $lastName = null;
  100.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  101.     #[ORM\Column(length: 100, nullable: true)]
  102.     private ?string $phone = null;
  104.     #[Groups(['user:read', 'user:create', 'user:update'])]
  105.     #[ORM\Column(length: 255, nullable: true)]
  106.     private ?string $address = null; 
  108.     #[Groups(['user:read', 'user:create', 'user:update'])]
  109.     #[ORM\Column(length: 50, nullable: true)]
  110.     private ?string $status = null;
  112.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLikeList::class)]
  113.     private Collection $userLikeLists;
  115.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: Products::class)]
  116.     private Collection $products;
  118.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Products::class)]
  119.     private Collection $create_products;
  121.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Orders::class)]
  122.     private Collection $orders;
  124.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Orders::class)]
  125.     private Collection $managerOrders;
  127.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  128.     #[ORM\Column(length: 255, nullable: true)]
  129.     private ?string $email = null;
  131.     #[Groups(['user:read', 'user:create', 'user:update', 'read'])]
  132.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Accounts::class)]
  133.     private Collection $accounts;
  135.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: LoadInvoice::class)]
  136.     private Collection $loadInvoices;
  138.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accepted::class)]
  139.     private Collection $acceptedsManager;
  140.  
  141.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Accepted::class)]
  142.     private Collection $acceptedsClients;
  144.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  145.     private Collection $n;
  147.     #[ORM\Column(length: 20, nullable: true)]
  148.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  149.     private ?string $codeUser = null;
  151.     #[ORM\Column(length: 20, nullable: true)]
  152.     #[Groups(['user:read', 'account:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  153.     private ?string $codeManager = null;
  155.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accounts::class)]
  156.     private Collection $managerAccounts;
  158.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: PreOrder::class)]
  159.     private Collection $preOrders;
  161.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: PreOrder::class)]
  162.     private Collection $ManagerPreOrders;
  164.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  165.     #[ORM\Column(length: 255, nullable: true)]
  166.     private ?string $workSchedule = null;
  168.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  169.     #[ORM\Column(length: 255, nullable: true)]
  170.     private ?string $telegram = null;
  172.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  173.     #[ORM\Column(length: 255, nullable: true)]
  174.     private ?string $viber = null;
  176.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  177.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
  178.     private Collection $mediaObjects;
  180.     #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'users')]
  181.     private Collection $coupons;
  183.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  184.     private Collection $productBalanceInStorages;
  186.     #[Groups(['user:read', 'user:create', 'user:update'])]
  187.     #[ORM\ManyToOne(inversedBy: 'users')]
  188.     private ?Location $location = null;
  190.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: Comments::class)]
  191.     private Collection $comments;
  193.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Faq::class)]
  194.     private Collection $faqs;
  196.     #[ORM\OneToMany(mappedBy: 'modifiedUser', targetEntity: Faq::class)]
  197.     private Collection $modifiedFaq;
  201.     public function __construct()
  202.     {
  203.         $this->userLikeLists = new ArrayCollection();
  204.         $this->products = new ArrayCollection();
  205.         $this->create_products = new ArrayCollection();
  206.         $this->orders = new ArrayCollection();
  207.         $this->managerOrders = new ArrayCollection();
  208.         $this->accounts = new ArrayCollection();
  209.         $this->loadInvoices = new ArrayCollection();
  210.         $this->acceptedsManager = new ArrayCollection();
  211.         $this->acceptedsClients = new ArrayCollection();
  212.         $this->n = new ArrayCollection();
  213.         $this->managerAccounts = new ArrayCollection();
  214.         $this->preOrders = new ArrayCollection();
  215.         $this->ManagerPreOrders = new ArrayCollection();
  216.         $this->mediaObjects = new ArrayCollection();
  217.         $this->coupons = new ArrayCollection();
  218.         $this->productBalanceInStorages = new ArrayCollection();
  219.         $this->comments = new ArrayCollection();
  220.         $this->faqs = new ArrayCollection();
  221.         $this->modifiedFaq = new ArrayCollection();
  222.     }
  224.     public function getId(): ?int
  225.     {
  226.         return $this->id;
  227.     }
  229.     /**
  230.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  231.      */
  232.     public function getUsername(): string
  233.     {
  234.         return (string) $this->username;
  235.     }
  237.     public function setUsername(string $username): self
  238.     {
  239.         $this->username = $username;
  241.         return $this;
  242.     }
  244.     /**
  245.      * A visual identifier that represents this user.
  246.      *
  247.      * @see UserInterface
  248.      */
  249.     public function getUserIdentifier(): string
  250.     {
  251.         return (string) $this->username;
  252.     }
  254.     /**
  255.      * @see UserInterface
  256.      */
  257.     public function getRoles(): array
  258.     {
  259.         $roles = $this->roles;
  260.         // guarantee every user at least has ROLE_USER
  261.         $roles[] = 'ROLE_USER';
  263.         return array_unique($roles);
  264.     }
  266.     public function setRoles(array $roles): self
  267.     {
  268.         $this->roles = $roles;
  270.         return $this;
  271.     }
  273.     /**
  274.      * @see PasswordAuthenticatedUserInterface
  275.      */
  276.     public function getPassword(): string
  277.     {
  278.         return $this->password;
  279.     }
  281.     public function setPassword(string $password): self
  282.     {
  283.         $this->password = $password;
  285.         return $this;
  286.     }
  288.     public function getPlainPassword(): ?string
  289.     {
  290.         return $this->plainPassword;
  291.     }
  293.     public function setPlainPassword(?string $plainPassword): self
  294.     {
  295.         $this->plainPassword = $plainPassword;
  297.         return $this;
  298.     }
  300.     /**
  301.      * Returning a salt is only needed, if you are not using a modern
  302.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  303.      *
  304.      * @see UserInterface
  305.      */
  306.     public function getSalt(): ?string
  307.     {
  308.         return null;
  309.     }
  311.     /**
  312.      * @see UserInterface
  313.      */
  314.     public function eraseCredentials()
  315.     {
  316.         // If you store any temporary, sensitive data on the user, clear it here
  317.         $this->plainPassword = null;
  318.     }
  320.     public function getFirstName(): ?string
  321.     {
  322.         return $this->firstName;
  323.     }
  326.     public function setFirstName(string $firstName): self
  327.     {
  328.         $this->firstName = $firstName;
  330.         return $this;
  331.     }
  333.     public function getLastName(): ?string
  334.     {
  335.         return $this->lastName;
  336.     }
  338.     public function setLastName(string $lastName): self
  339.     {
  340.         $this->lastName = $lastName;
  342.         return $this;
  343.     }
  345.     public function getPhone(): ?string
  346.     {
  347.         return $this->phone;
  348.     }
  350.     public function setPhone(?string $phone): self
  351.     {
  352.         $this->phone = $phone;
  354.         return $this;
  355.     }
  357.     public function getAddress(): ?string
  358.     {
  359.         return $this->address;
  360.     }
  362.     public function setAddress(?string $address): self
  363.     {
  364.         $this->address = $address;
  366.         return $this;
  367.     }
  369.     public function getStatus(): ?string
  370.     {
  371.         return $this->status;
  372.     }
  374.     public function setStatus(?string $status): self
  375.     {
  376.         $this->status = $status;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, UserLikeList>
  383.      */
  384.     public function getUserLikeLists(): Collection
  385.     {
  386.         return $this->userLikeLists;
  387.     }
  389.     public function addUserLikeList(UserLikeList $userLikeList): self
  390.     {
  391.         if (!$this->userLikeLists->contains($userLikeList)) {
  392.             $this->userLikeLists->add($userLikeList);
  393.             $userLikeList->setUserId($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeUserLikeList(UserLikeList $userLikeList): self
  400.     {
  401.         if ($this->userLikeLists->removeElement($userLikeList)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($userLikeList->getUserId() === $this) {
  404.                 $userLikeList->setUserId(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection<int, Products>
  413.      */
  414.     public function getProducts(): Collection
  415.     {
  416.         return $this->products;
  417.     }
  419.     public function addProduct(Products $product): self
  420.     {
  421.         if (!$this->products->contains($product)) {
  422.             $this->products->add($product);
  423.             $product->setModifiedUserId($this);
  424.         }
  426.         return $this;
  427.     }
  429.     // public function removeProduct(Products $product): self
  430.     // {
  431.     //     if ($this->products->removeElement($product)) {
  432.     //         // set the owning side to null (unless already changed)
  433.     //         if ($product->getModifiedUserId() === $this) {
  434.     //             $product->setModifiedUserId(null);
  435.     //         }
  436.     //     }
  438.     //     return $this;
  439.     // }
  441.     /**
  442.      * @return Collection<int, Products>
  443.      */
  444.     public function getCreateProducts(): Collection
  445.     {
  446.         return $this->create_products;
  447.     }
  449.     public function addCreateProduct(Products $createProduct): self
  450.     {
  451.         if (!$this->create_products->contains($createProduct)) {
  452.             $this->create_products->add($createProduct);
  453.             $createProduct->setCreatedBy($this);
  454.         }
  456.         return $this;
  457.     }
  459.     // public function removeCreateProduct(Products $createProduct): self
  460.     // {
  461.     //     if ($this->create_products->removeElement($createProduct)) {
  462.     //         // set the owning side to null (unless already changed)
  463.     //         if ($createProduct->getCreatedBy() === $this) {
  464.     //             $createProduct->setCreatedBy(null);
  465.     //         }
  466.     //     }
  468.     //     return $this;
  469.     // }
  471.     /**
  472.      * @return Collection<int, Orders>
  473.      */
  474.     public function getOrders(): Collection
  475.     {
  476.         return $this->orders;
  477.     }
  479.     public function addOrder(Orders $order): self
  480.     {
  481.         if (!$this->orders->contains($order)) {
  482.             $this->orders->add($order);
  483.             $order->setUserId($this);
  484.         }
  486.         return $this;
  487.     }
  489.     // public function removeOrder(Orders $order): self
  490.     // {
  491.     //     if ($this->orders->removeElement($order)) {
  492.     //         // set the owning side to null (unless already changed)
  493.     //         if ($order->getUserId() === $this) {
  494.     //             $order->setUserId(null);
  495.     //         }
  496.     //     }
  498.     //     return $this;
  499.     // }
  501.     /**
  502.      * @return Collection<int, Orders>
  503.      */
  504.     public function getManagerOrders(): Collection
  505.     {
  506.         return $this->managerOrders;
  507.     }
  509.     public function addManagerOrder(Orders $managerOrder): self
  510.     {
  511.         if (!$this->managerOrders->contains($managerOrder)) {
  512.             $this->managerOrders->add($managerOrder);
  513.             $managerOrder->setManagerId($this);
  514.         }
  516.         return $this;
  517.     }
  519.     // public function removeManagerOrder(Orders $managerOrder): self
  520.     // {
  521.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  522.     //         // set the owning side to null (unless already changed)
  523.     //         if ($managerOrder->getManagerId() === $this) {
  524.     //             $managerOrder->setManagerId(null);
  525.     //         }
  526.     //     }
  528.     //     return $this;
  529.     // }
  531.     public function getEmail(): ?string
  532.     {
  533.         return $this->email;
  534.     }
  536.     public function setEmail(?string $email): self
  537.     {
  538.         $this->email = $email;
  540.         return $this;
  541.     }
  543.     /**
  544.      * @return Collection<int, Accounts>
  545.      */
  546.     public function getAccounts(): Collection
  547.     {
  548.         return $this->accounts;
  549.     }
  551.     public function addAccount(Accounts $account): self
  552.     {
  553.         if (!$this->accounts->contains($account)) {
  554.             $this->accounts->add($account);
  555.             $account->setUserId($this);
  556.         }
  558.         return $this;
  559.     }
  561.     public function removeAccount(Accounts $account): self
  562.     {
  563.         if ($this->accounts->removeElement($account)) {
  564.             // set the owning side to null (unless already changed)
  565.             if ($account->getUserId() === $this) {
  566.                 $account->setUserId(null);
  567.             }
  568.         }
  570.         return $this;
  571.     }
  573.     /**
  574.      * @return Collection<int, LoadInvoice>
  575.      */
  576.     public function getLoadInvoices(): Collection
  577.     {
  578.         return $this->loadInvoices;
  579.     }
  581.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  582.     {
  583.         if (!$this->loadInvoices->contains($loadInvoice)) {
  584.             $this->loadInvoices->add($loadInvoice);
  585.             $loadInvoice->setClient($this);
  586.         }
  588.         return $this;
  589.     }
  591.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  592.     {
  593.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  594.             // set the owning side to null (unless already changed)
  595.             if ($loadInvoice->getClient() === $this) {
  596.                 $loadInvoice->setClient(null);
  597.             }
  598.         }
  600.         return $this;
  601.     }
  603.     /**
  604.      * @return Collection<int, Accepted>
  605.      * acceptedsManager
  606.         *acceptedsClients
  607.      */
  608.     public function getAcceptedsManager(): Collection
  609.     {
  610.         return $this->acceptedsManager;
  611.     }
  613.     public function addAcceptedsManager(Accepted $acceptedsManager): self
  614.     {
  615.         if (!$this->acceptedsManager->contains($acceptedsManager)) {
  616.             $this->acceptedsManager->add($acceptedsManager);
  617.             $acceptedsManager->setManager($this);
  618.         }
  620.         return $this;
  621.     }
  623.     public function removeAcceptedsManager(Accepted $acceptedsManager): self
  624.     {
  625.         if ($this->acceptedsManager->removeElement($acceptedsManager)) {
  626.             // set the owning side to null (unless already changed)
  627.             if ($acceptedsManager->getManager() === $this) {
  628.                 $acceptedsManager->setManager(null);
  629.             }
  630.         }
  632.         return $this;
  633.     }
  635.     /**
  636.      * @return Collection<int, Accepted>
  637.      * acceptedsManager
  638.         *acceptedsClients
  639.      */
  640.     public function getAcceptedsClients(): Collection
  641.     {
  642.         return $this->acceptedsClients;
  643.     }
  645.     public function addAcceptedsClients(Accepted $acceptedsClients): self
  646.     {
  647.         if (!$this->acceptedsClients->contains($acceptedsClients)) {
  648.             $this->acceptedsClients->add($acceptedsClients);
  649.             $acceptedsClients->setManager($this);
  650.         }
  652.         return $this;
  653.     }
  655.     public function removeAcceptedsClients(Accepted $acceptedsClients): self
  656.     {
  657.         if ($this->acceptedsClients->removeElement($acceptedsClients)) {
  658.             // set the owning side to null (unless already changed)
  659.             if ($acceptedsClients->getManager() === $this) {
  660.                 $acceptedsClients->setManager(null);
  661.             }
  662.         }
  664.         return $this;
  665.     }
  667.     /**
  668.      * @return Collection<int, AcceptedProduct>
  669.      */
  670.     public function getN(): Collection
  671.     {
  672.         return $this->n;
  673.     }
  675.     public function addN(AcceptedProduct $n): self
  676.     {
  677.         if (!$this->n->contains($n)) {
  678.             $this->n->add($n);
  679.             $n->setModifiedUser($this);
  680.         }
  682.         return $this;
  683.     }
  685.     public function removeN(AcceptedProduct $n): self
  686.     {
  687.         if ($this->n->removeElement($n)) {
  688.             // set the owning side to null (unless already changed)
  689.             if ($n->getModifiedUser() === $this) {
  690.                 $n->setModifiedUser(null);
  691.             }
  692.         }
  694.         return $this;
  695.     }
  697.     public function getCodeUser(): ?string
  698.     {
  699.         return $this->codeUser;
  700.     }
  702.     public function setCodeUser(string $codeUser): self
  703.     {
  704.         $this->codeUser = $codeUser;
  706.         return $this;
  707.     }
  709.     public function getCodeManager(): ?string
  710.     {
  711.         return $this->codeManager;
  712.     }
  714.     public function setCodeManager(string $codeManager): self
  715.     {
  716.         $this->codeManager = $codeManager;
  718.         return $this;
  719.     }
  721.     /**
  722.      * @return Collection<int, Accounts>
  723.      */
  724.     public function getManagerAccounts(): Collection
  725.     {
  726.         return $this->managerAccounts;
  727.     }
  729.     public function addManagerAccount(Accounts $managerAccount): self
  730.     {
  731.         if (!$this->managerAccounts->contains($managerAccount)) {
  732.             $this->managerAccounts->add($managerAccount);
  733.             $managerAccount->setManager($this);
  734.         }
  736.         return $this;
  737.     }
  739.     public function removeManagerAccount(Accounts $managerAccount): self
  740.     {
  741.         if ($this->managerAccounts->removeElement($managerAccount)) {
  742.             // set the owning side to null (unless already changed)
  743.             if ($managerAccount->getManager() === $this) {
  744.                 $managerAccount->setManager(null);
  745.             }
  746.         }
  748.         return $this;
  749.     }
  751.     /**
  752.      * @return Collection<int, PreOrder>
  753.      */
  754.     public function getPreOrders(): Collection
  755.     {
  756.         return $this->preOrders;
  757.     }
  759.     public function addPreOrder(PreOrder $preOrder): self
  760.     {
  761.         if (!$this->preOrders->contains($preOrder)) {
  762.             $this->preOrders->add($preOrder);
  763.             $preOrder->setClient($this);
  764.         }
  766.         return $this;
  767.     }
  769.     public function removePreOrder(PreOrder $preOrder): self
  770.     {
  771.         if ($this->preOrders->removeElement($preOrder)) {
  772.             // set the owning side to null (unless already changed)
  773.             if ($preOrder->getClient() === $this) {
  774.                 $preOrder->setClient(null);
  775.             }
  776.         }
  778.         return $this;
  779.     }
  781.     /**
  782.      * @return Collection<int, PreOrder>
  783.      */
  784.     public function getManagerPreOrders(): Collection
  785.     {
  786.         return $this->ManagerPreOrders;
  787.     }
  789.     public function addManagerPreOrder(PreOrder $managerPreOrder): self
  790.     {
  791.         if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  792.             $this->ManagerPreOrders->add($managerPreOrder);
  793.             $managerPreOrder->setManager($this);
  794.         }
  796.         return $this;
  797.     }
  799.     public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  800.     {
  801.         if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  802.             // set the owning side to null (unless already changed)
  803.             if ($managerPreOrder->getManager() === $this) {
  804.                 $managerPreOrder->setManager(null);
  805.             }
  806.         }
  808.         return $this;
  809.     }
  811.     public function getWorkSchedule(): ?string
  812.     {
  813.         return $this->workSchedule;
  814.     }
  816.     public function setWorkSchedule(?string $workSchedule): self
  817.     {
  818.         $this->workSchedule = $workSchedule;
  820.         return $this;
  821.     }
  823.     public function getTelegram(): ?string
  824.     {
  825.         return $this->telegram;
  826.     }
  828.     public function setTelegram(?string $telegram): self
  829.     {
  830.         $this->telegram = $telegram;
  832.         return $this;
  833.     }
  835.     public function getViber(): ?string
  836.     {
  837.         return $this->viber;
  838.     }
  840.     public function setViber(?string $viber): self
  841.     {
  842.         $this->viber = $viber;
  844.         return $this;
  845.     }
  847.     /**
  848.      * @return Collection<int, MediaObject>
  849.      */
  850.     public function getMediaObjects(): Collection
  851.     {
  852.         return $this->mediaObjects;
  853.     }
  855.     public function addMediaObject(MediaObject $mediaObject): self
  856.     {
  857.         if (!$this->mediaObjects->contains($mediaObject)) {
  858.             $this->mediaObjects->add($mediaObject);
  859.             $mediaObject->setUsers($this);
  860.         }
  862.         return $this;
  863.     }
  865.     public function removeMediaObject(MediaObject $mediaObject): self
  866.     {
  867.         if ($this->mediaObjects->removeElement($mediaObject)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($mediaObject->getUsers() === $this) {
  870.                 $mediaObject->setUsers(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     /**
  878.      * @return Collection<int, Coupons>
  879.      */
  880.     public function getCoupons(): Collection
  881.     {
  882.         return $this->coupons;
  883.     }
  885.     public function addCoupon(Coupons $coupon): self
  886.     {
  887.         if (!$this->coupons->contains($coupon)) {
  888.             $this->coupons->add($coupon);
  889.             $coupon->addUser($this);
  890.         }
  892.         return $this;
  893.     }
  895.     public function removeCoupon(Coupons $coupon): self
  896.     {
  897.         if ($this->coupons->removeElement($coupon)) {
  898.             $coupon->removeUser($this);
  899.         }
  901.         return $this;
  902.     }
  904.     /**
  905.      * @return Collection<int, ProductBalanceInStorage>
  906.      */
  907.     public function getProductBalanceInStorages(): Collection
  908.     {
  909.         return $this->productBalanceInStorages;
  910.     }
  912.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  913.     {
  914.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  915.             $this->productBalanceInStorages->add($productBalanceInStorage);
  916.             $productBalanceInStorage->setManager($this);
  917.         }
  919.         return $this;
  920.     }
  922.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  923.     {
  924.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  925.             // set the owning side to null (unless already changed)
  926.             if ($productBalanceInStorage->getManager() === $this) {
  927.                 $productBalanceInStorage->setManager(null);
  928.             }
  929.         }
  931.         return $this;
  932.     }
  934.     public function getLocation(): ?Location
  935.     {
  936.         return $this->location;
  937.     }
  939.     public function setLocation(?Location $location): self
  940.     {
  941.         $this->location = $location;
  943.         return $this;
  944.     }
  946.     /**
  947.      * @return Collection<int, Comments>
  948.      */
  949.     public function getComments(): Collection
  950.     {
  951.         return $this->comments;
  952.     }
  954.     public function addComment(Comments $comment): static
  955.     {
  956.         if (!$this->comments->contains($comment)) {
  957.             $this->comments->add($comment);
  958.             $comment->setUsers($this);
  959.         }
  961.         return $this;
  962.     }
  964.     public function removeComment(Comments $comment): static
  965.     {
  966.         if ($this->comments->removeElement($comment)) {
  967.             // set the owning side to null (unless already changed)
  968.             if ($comment->getUsers() === $this) {
  969.                 $comment->setUsers(null);
  970.             }
  971.         }
  973.         return $this;
  974.     }
  976.     /**
  977.      * @return Collection<int, Faq>
  978.      */
  979.     public function getFaqs(): Collection
  980.     {
  981.         return $this->faqs;
  982.     }
  984.     public function addFaq(Faq $faq): static
  985.     {
  986.         if (!$this->faqs->contains($faq)) {
  987.             $this->faqs->add($faq);
  988.             $faq->setCreatedBy($this);
  989.         }
  991.         return $this;
  992.     }
  994.     public function removeFaq(Faq $faq): static
  995.     {
  996.         if ($this->faqs->removeElement($faq)) {
  997.             // set the owning side to null (unless already changed)
  998.             if ($faq->getCreatedBy() === $this) {
  999.                 $faq->setCreatedBy(null);
  1000.             }
  1001.         }
  1003.         return $this;
  1004.     }
  1006.     /**
  1007.      * @return Collection<int, Faq>
  1008.      */
  1009.     public function getModifiedFaq(): Collection
  1010.     {
  1011.         return $this->modifiedFaq;
  1012.     }
  1014.     public function addModifiedFaq(Faq $modifiedFaq): static
  1015.     {
  1016.         if (!$this->modifiedFaq->contains($modifiedFaq)) {
  1017.             $this->modifiedFaq->add($modifiedFaq);
  1018.             $modifiedFaq->setModifiedUser($this);
  1019.         }
  1021.         return $this;
  1022.     }
  1024.     public function removeModifiedFaq(Faq $modifiedFaq): static
  1025.     {
  1026.         if ($this->modifiedFaq->removeElement($modifiedFaq)) {
  1027.             // set the owning side to null (unless already changed)
  1028.             if ($modifiedFaq->getModifiedUser() === $this) {
  1029.                 $modifiedFaq->setModifiedUser(null);
  1030.             }
  1031.         }
  1033.         return $this;
  1034.     }
  1036. }