src/Entity/User.php line 64

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.     ],
  45.     normalizationContext: ['groups' => ['user:read']],
  46.     denormalizationContext: ['groups' => ['user:create', 'user:update']],
  48. )]
  49. #[ORM\Entity(repositoryClass: UserRepository::class)]
  50. #[UniqueEntity(fields: ['username'], message: 'There is already an account with this username')]
  51. #[ApiFilter(CustomOrFilter::class,properties: [
  52.     'username' => 'ipartial', 
  53.     'firstName' => 'ipartial', 
  54.     'lastName' => 'ipartial',
  55.     'codeUser' => 'exact',
  56.     'codeManager' => 'exact',
  57. ])]
  59. #[ApiFilter(SearchFilter::class, properties: [
  61.     'accounts.manager.id' => 'exact',
  62. ])]
  64. class User implements UserInterface, PasswordAuthenticatedUserInterface
  65. {
  66.     #[ORM\Id]
  67.     #[ORM\GeneratedValue]
  68.     #[ORM\Column]
  69.     #[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'])]
  70.     private ?int $id = null;
  72.     #[ORM\Column(length: 180, unique: true)]
  73.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  74.     private ?string $username = null;
  76.     #[Groups(['user:read', 'user:update'])]
  77.     #[ORM\Column]
  78.     private array $roles = [];
  80.     /**
  81.      * @var string The hashed password
  82.      */
  83.     #[ORM\Column]
  84.     private ?string $password = null;
  86.     #[Assert\NotBlank(groups: ['user:create'])]
  87.     #[Groups(['user:create', 'user:update'])]
  88.     private ?string $plainPassword = null;
  91.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'firstName')]
  92.     private ?self $manager = 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'])]
  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'])]
  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: 'user', 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 $accepteds;
  143.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  144.     private Collection $n;
  146.     #[ORM\Column(length: 20, nullable: true)]
  147.     #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  148.     private ?string $codeUser = null;
  150.     #[ORM\Column(length: 20, nullable: true)]
  151.     #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read'])]
  152.     private ?string $codeManager = null;
  154.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accounts::class)]
  155.     private Collection $managerAccounts;
  157.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: PreOrder::class)]
  158.     private Collection $preOrders;
  160.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: PreOrder::class)]
  161.     private Collection $ManagerPreOrders;
  163.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  164.     #[ORM\Column(length: 255, nullable: true)]
  165.     private ?string $workSchedule = null;
  167.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  168.     #[ORM\Column(length: 255, nullable: true)]
  169.     private ?string $telegram = null;
  171.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  172.     #[ORM\Column(length: 255, nullable: true)]
  173.     private ?string $viber = null;
  175.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  176.     #[ORM\OneToMany(mappedBy: 'users', targetEntity: MediaObject::class)]
  177.     private Collection $mediaObjects;
  179.     #[ORM\ManyToMany(targetEntity: Coupons::class, mappedBy: 'users')]
  180.     private Collection $coupons;
  182.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  183.     private Collection $productBalanceInStorages;
  185.     #[Groups(['user:read', 'user:create', 'user:update'])]
  186.     #[ORM\ManyToOne(inversedBy: 'users')]
  187.     private ?Location $location = null;
  191.     public function __construct()
  192.     {
  193.         $this->userLikeLists = new ArrayCollection();
  194.         $this->products = new ArrayCollection();
  195.         $this->create_products = new ArrayCollection();
  196.         $this->orders = new ArrayCollection();
  197.         $this->managerOrders = new ArrayCollection();
  198.         $this->accounts = new ArrayCollection();
  199.         $this->loadInvoices = new ArrayCollection();
  200.         $this->accepteds = new ArrayCollection();
  201.         $this->n = new ArrayCollection();
  202.         $this->managerAccounts = new ArrayCollection();
  203.         $this->preOrders = new ArrayCollection();
  204.         $this->ManagerPreOrders = new ArrayCollection();
  205.         $this->mediaObjects = new ArrayCollection();
  206.         $this->coupons = new ArrayCollection();
  207.         $this->productBalanceInStorages = new ArrayCollection();
  208.     }
  210.     public function getId(): ?int
  211.     {
  212.         return $this->id;
  213.     }
  215.     /**
  216.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  217.      */
  218.     public function getUsername(): string
  219.     {
  220.         return (string) $this->username;
  221.     }
  223.     public function setUsername(string $username): self
  224.     {
  225.         $this->username = $username;
  227.         return $this;
  228.     }
  230.     /**
  231.      * A visual identifier that represents this user.
  232.      *
  233.      * @see UserInterface
  234.      */
  235.     public function getUserIdentifier(): string
  236.     {
  237.         return (string) $this->username;
  238.     }
  240.     /**
  241.      * @see UserInterface
  242.      */
  243.     public function getRoles(): array
  244.     {
  245.         $roles = $this->roles;
  246.         // guarantee every user at least has ROLE_USER
  247.         $roles[] = 'ROLE_USER';
  249.         return array_unique($roles);
  250.     }
  252.     public function setRoles(array $roles): self
  253.     {
  254.         $this->roles = $roles;
  256.         return $this;
  257.     }
  259.     /**
  260.      * @see PasswordAuthenticatedUserInterface
  261.      */
  262.     public function getPassword(): string
  263.     {
  264.         return $this->password;
  265.     }
  267.     public function setPassword(string $password): self
  268.     {
  269.         $this->password = $password;
  271.         return $this;
  272.     }
  274.     public function getPlainPassword(): ?string
  275.     {
  276.         return $this->plainPassword;
  277.     }
  279.     public function setPlainPassword(?string $plainPassword): self
  280.     {
  281.         $this->plainPassword = $plainPassword;
  283.         return $this;
  284.     }
  286.     /**
  287.      * Returning a salt is only needed, if you are not using a modern
  288.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  289.      *
  290.      * @see UserInterface
  291.      */
  292.     public function getSalt(): ?string
  293.     {
  294.         return null;
  295.     }
  297.     /**
  298.      * @see UserInterface
  299.      */
  300.     public function eraseCredentials()
  301.     {
  302.         // If you store any temporary, sensitive data on the user, clear it here
  303.         $this->plainPassword = null;
  304.     }
  306.     public function getManagerId(): ?self
  307.     {
  308.         return $this->manager;
  309.     }
  311.     public function setManagerId(?self $manager): self
  312.     {
  313.         $this->manager = $manager;
  315.         return $this;
  316.     }
  317.     
  318.     public function getFirstName(): ?string
  319.     {
  320.         return $this->firstName;
  321.     }
  324.     public function setFirstName(string $firstName): self
  325.     {
  326.         $this->firstName = $firstName;
  328.         return $this;
  329.     }
  331.     public function getLastName(): ?string
  332.     {
  333.         return $this->lastName;
  334.     }
  336.     public function setLastName(string $lastName): self
  337.     {
  338.         $this->lastName = $lastName;
  340.         return $this;
  341.     }
  343.     public function getPhone(): ?string
  344.     {
  345.         return $this->phone;
  346.     }
  348.     public function setPhone(?string $phone): self
  349.     {
  350.         $this->phone = $phone;
  352.         return $this;
  353.     }
  355.     public function getAddress(): ?string
  356.     {
  357.         return $this->address;
  358.     }
  360.     public function setAddress(?string $address): self
  361.     {
  362.         $this->address = $address;
  364.         return $this;
  365.     }
  367.     public function getStatus(): ?string
  368.     {
  369.         return $this->status;
  370.     }
  372.     public function setStatus(?string $status): self
  373.     {
  374.         $this->status = $status;
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection<int, UserLikeList>
  381.      */
  382.     public function getUserLikeLists(): Collection
  383.     {
  384.         return $this->userLikeLists;
  385.     }
  387.     public function addUserLikeList(UserLikeList $userLikeList): self
  388.     {
  389.         if (!$this->userLikeLists->contains($userLikeList)) {
  390.             $this->userLikeLists->add($userLikeList);
  391.             $userLikeList->setUserId($this);
  392.         }
  394.         return $this;
  395.     }
  397.     public function removeUserLikeList(UserLikeList $userLikeList): self
  398.     {
  399.         if ($this->userLikeLists->removeElement($userLikeList)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($userLikeList->getUserId() === $this) {
  402.                 $userLikeList->setUserId(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  409.     /**
  410.      * @return Collection<int, Products>
  411.      */
  412.     public function getProducts(): Collection
  413.     {
  414.         return $this->products;
  415.     }
  417.     public function addProduct(Products $product): self
  418.     {
  419.         if (!$this->products->contains($product)) {
  420.             $this->products->add($product);
  421.             $product->setModifiedUserId($this);
  422.         }
  424.         return $this;
  425.     }
  427.     // public function removeProduct(Products $product): self
  428.     // {
  429.     //     if ($this->products->removeElement($product)) {
  430.     //         // set the owning side to null (unless already changed)
  431.     //         if ($product->getModifiedUserId() === $this) {
  432.     //             $product->setModifiedUserId(null);
  433.     //         }
  434.     //     }
  436.     //     return $this;
  437.     // }
  439.     /**
  440.      * @return Collection<int, Products>
  441.      */
  442.     public function getCreateProducts(): Collection
  443.     {
  444.         return $this->create_products;
  445.     }
  447.     public function addCreateProduct(Products $createProduct): self
  448.     {
  449.         if (!$this->create_products->contains($createProduct)) {
  450.             $this->create_products->add($createProduct);
  451.             $createProduct->setCreatedBy($this);
  452.         }
  454.         return $this;
  455.     }
  457.     // public function removeCreateProduct(Products $createProduct): self
  458.     // {
  459.     //     if ($this->create_products->removeElement($createProduct)) {
  460.     //         // set the owning side to null (unless already changed)
  461.     //         if ($createProduct->getCreatedBy() === $this) {
  462.     //             $createProduct->setCreatedBy(null);
  463.     //         }
  464.     //     }
  466.     //     return $this;
  467.     // }
  469.     /**
  470.      * @return Collection<int, Orders>
  471.      */
  472.     public function getOrders(): Collection
  473.     {
  474.         return $this->orders;
  475.     }
  477.     public function addOrder(Orders $order): self
  478.     {
  479.         if (!$this->orders->contains($order)) {
  480.             $this->orders->add($order);
  481.             $order->setUserId($this);
  482.         }
  484.         return $this;
  485.     }
  487.     // public function removeOrder(Orders $order): self
  488.     // {
  489.     //     if ($this->orders->removeElement($order)) {
  490.     //         // set the owning side to null (unless already changed)
  491.     //         if ($order->getUserId() === $this) {
  492.     //             $order->setUserId(null);
  493.     //         }
  494.     //     }
  496.     //     return $this;
  497.     // }
  499.     /**
  500.      * @return Collection<int, Orders>
  501.      */
  502.     public function getManagerOrders(): Collection
  503.     {
  504.         return $this->managerOrders;
  505.     }
  507.     public function addManagerOrder(Orders $managerOrder): self
  508.     {
  509.         if (!$this->managerOrders->contains($managerOrder)) {
  510.             $this->managerOrders->add($managerOrder);
  511.             $managerOrder->setManagerId($this);
  512.         }
  514.         return $this;
  515.     }
  517.     // public function removeManagerOrder(Orders $managerOrder): self
  518.     // {
  519.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  520.     //         // set the owning side to null (unless already changed)
  521.     //         if ($managerOrder->getManagerId() === $this) {
  522.     //             $managerOrder->setManagerId(null);
  523.     //         }
  524.     //     }
  526.     //     return $this;
  527.     // }
  529.     public function getEmail(): ?string
  530.     {
  531.         return $this->email;
  532.     }
  534.     public function setEmail(?string $email): self
  535.     {
  536.         $this->email = $email;
  538.         return $this;
  539.     }
  541.     /**
  542.      * @return Collection<int, Accounts>
  543.      */
  544.     public function getAccounts(): Collection
  545.     {
  546.         return $this->accounts;
  547.     }
  549.     public function addAccount(Accounts $account): self
  550.     {
  551.         if (!$this->accounts->contains($account)) {
  552.             $this->accounts->add($account);
  553.             $account->setUserId($this);
  554.         }
  556.         return $this;
  557.     }
  559.     public function removeAccount(Accounts $account): self
  560.     {
  561.         if ($this->accounts->removeElement($account)) {
  562.             // set the owning side to null (unless already changed)
  563.             if ($account->getUserId() === $this) {
  564.                 $account->setUserId(null);
  565.             }
  566.         }
  568.         return $this;
  569.     }
  571.     /**
  572.      * @return Collection<int, LoadInvoice>
  573.      */
  574.     public function getLoadInvoices(): Collection
  575.     {
  576.         return $this->loadInvoices;
  577.     }
  579.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  580.     {
  581.         if (!$this->loadInvoices->contains($loadInvoice)) {
  582.             $this->loadInvoices->add($loadInvoice);
  583.             $loadInvoice->setClient($this);
  584.         }
  586.         return $this;
  587.     }
  589.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  590.     {
  591.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  592.             // set the owning side to null (unless already changed)
  593.             if ($loadInvoice->getClient() === $this) {
  594.                 $loadInvoice->setClient(null);
  595.             }
  596.         }
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return Collection<int, Accepted>
  603.      */
  604.     public function getAccepteds(): Collection
  605.     {
  606.         return $this->accepteds;
  607.     }
  609.     public function addAccepted(Accepted $accepted): self
  610.     {
  611.         if (!$this->accepteds->contains($accepted)) {
  612.             $this->accepteds->add($accepted);
  613.             $accepted->setManager($this);
  614.         }
  616.         return $this;
  617.     }
  619.     public function removeAccepted(Accepted $accepted): self
  620.     {
  621.         if ($this->accepteds->removeElement($accepted)) {
  622.             // set the owning side to null (unless already changed)
  623.             if ($accepted->getManager() === $this) {
  624.                 $accepted->setManager(null);
  625.             }
  626.         }
  628.         return $this;
  629.     }
  631.     /**
  632.      * @return Collection<int, AcceptedProduct>
  633.      */
  634.     public function getN(): Collection
  635.     {
  636.         return $this->n;
  637.     }
  639.     public function addN(AcceptedProduct $n): self
  640.     {
  641.         if (!$this->n->contains($n)) {
  642.             $this->n->add($n);
  643.             $n->setModifiedUser($this);
  644.         }
  646.         return $this;
  647.     }
  649.     public function removeN(AcceptedProduct $n): self
  650.     {
  651.         if ($this->n->removeElement($n)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($n->getModifiedUser() === $this) {
  654.                 $n->setModifiedUser(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     public function getCodeUser(): ?string
  662.     {
  663.         return $this->codeUser;
  664.     }
  666.     public function setCodeUser(string $codeUser): self
  667.     {
  668.         $this->codeUser = $codeUser;
  670.         return $this;
  671.     }
  673.     public function getCodeManager(): ?string
  674.     {
  675.         return $this->codeManager;
  676.     }
  678.     public function setCodeManager(string $codeManager): self
  679.     {
  680.         $this->codeManager = $codeManager;
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection<int, Accounts>
  687.      */
  688.     public function getManagerAccounts(): Collection
  689.     {
  690.         return $this->managerAccounts;
  691.     }
  693.     public function addManagerAccount(Accounts $managerAccount): self
  694.     {
  695.         if (!$this->managerAccounts->contains($managerAccount)) {
  696.             $this->managerAccounts->add($managerAccount);
  697.             $managerAccount->setManager($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeManagerAccount(Accounts $managerAccount): self
  704.     {
  705.         if ($this->managerAccounts->removeElement($managerAccount)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($managerAccount->getManager() === $this) {
  708.                 $managerAccount->setManager(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return Collection<int, PreOrder>
  717.      */
  718.     public function getPreOrders(): Collection
  719.     {
  720.         return $this->preOrders;
  721.     }
  723.     public function addPreOrder(PreOrder $preOrder): self
  724.     {
  725.         if (!$this->preOrders->contains($preOrder)) {
  726.             $this->preOrders->add($preOrder);
  727.             $preOrder->setClient($this);
  728.         }
  730.         return $this;
  731.     }
  733.     public function removePreOrder(PreOrder $preOrder): self
  734.     {
  735.         if ($this->preOrders->removeElement($preOrder)) {
  736.             // set the owning side to null (unless already changed)
  737.             if ($preOrder->getClient() === $this) {
  738.                 $preOrder->setClient(null);
  739.             }
  740.         }
  742.         return $this;
  743.     }
  745.     /**
  746.      * @return Collection<int, PreOrder>
  747.      */
  748.     public function getManagerPreOrders(): Collection
  749.     {
  750.         return $this->ManagerPreOrders;
  751.     }
  753.     public function addManagerPreOrder(PreOrder $managerPreOrder): self
  754.     {
  755.         if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  756.             $this->ManagerPreOrders->add($managerPreOrder);
  757.             $managerPreOrder->setManager($this);
  758.         }
  760.         return $this;
  761.     }
  763.     public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  764.     {
  765.         if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  766.             // set the owning side to null (unless already changed)
  767.             if ($managerPreOrder->getManager() === $this) {
  768.                 $managerPreOrder->setManager(null);
  769.             }
  770.         }
  772.         return $this;
  773.     }
  775.     public function getWorkSchedule(): ?string
  776.     {
  777.         return $this->workSchedule;
  778.     }
  780.     public function setWorkSchedule(?string $workSchedule): self
  781.     {
  782.         $this->workSchedule = $workSchedule;
  784.         return $this;
  785.     }
  787.     public function getTelegram(): ?string
  788.     {
  789.         return $this->telegram;
  790.     }
  792.     public function setTelegram(?string $telegram): self
  793.     {
  794.         $this->telegram = $telegram;
  796.         return $this;
  797.     }
  799.     public function getViber(): ?string
  800.     {
  801.         return $this->viber;
  802.     }
  804.     public function setViber(?string $viber): self
  805.     {
  806.         $this->viber = $viber;
  808.         return $this;
  809.     }
  811.     /**
  812.      * @return Collection<int, MediaObject>
  813.      */
  814.     public function getMediaObjects(): Collection
  815.     {
  816.         return $this->mediaObjects;
  817.     }
  819.     public function addMediaObject(MediaObject $mediaObject): self
  820.     {
  821.         if (!$this->mediaObjects->contains($mediaObject)) {
  822.             $this->mediaObjects->add($mediaObject);
  823.             $mediaObject->setUsers($this);
  824.         }
  826.         return $this;
  827.     }
  829.     public function removeMediaObject(MediaObject $mediaObject): self
  830.     {
  831.         if ($this->mediaObjects->removeElement($mediaObject)) {
  832.             // set the owning side to null (unless already changed)
  833.             if ($mediaObject->getUsers() === $this) {
  834.                 $mediaObject->setUsers(null);
  835.             }
  836.         }
  838.         return $this;
  839.     }
  841.     /**
  842.      * @return Collection<int, Coupons>
  843.      */
  844.     public function getCoupons(): Collection
  845.     {
  846.         return $this->coupons;
  847.     }
  849.     public function addCoupon(Coupons $coupon): self
  850.     {
  851.         if (!$this->coupons->contains($coupon)) {
  852.             $this->coupons->add($coupon);
  853.             $coupon->addUser($this);
  854.         }
  856.         return $this;
  857.     }
  859.     public function removeCoupon(Coupons $coupon): self
  860.     {
  861.         if ($this->coupons->removeElement($coupon)) {
  862.             $coupon->removeUser($this);
  863.         }
  865.         return $this;
  866.     }
  868.     /**
  869.      * @return Collection<int, ProductBalanceInStorage>
  870.      */
  871.     public function getProductBalanceInStorages(): Collection
  872.     {
  873.         return $this->productBalanceInStorages;
  874.     }
  876.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  877.     {
  878.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  879.             $this->productBalanceInStorages->add($productBalanceInStorage);
  880.             $productBalanceInStorage->setManager($this);
  881.         }
  883.         return $this;
  884.     }
  886.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  887.     {
  888.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  889.             // set the owning side to null (unless already changed)
  890.             if ($productBalanceInStorage->getManager() === $this) {
  891.                 $productBalanceInStorage->setManager(null);
  892.             }
  893.         }
  895.         return $this;
  896.     }
  898.     public function getLocation(): ?Location
  899.     {
  900.         return $this->location;
  901.     }
  903.     public function setLocation(?Location $location): self
  904.     {
  905.         $this->location = $location;
  907.         return $this;
  908.     }
  910. }