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.     ],
  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')]
  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: [
  61.     'username' => 'exact',
  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',  'user_docs:read', 'product:read', 'job:read'])]
  71.     private ?int $id = null;
  73.     #[ORM\Column(length: 180, unique: true)]
  74.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read', 'user_docs: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.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'firstName')]
  93.     private ?self $manager = null;
  95.     #[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', 'job:read'])]
  96.     #[ORM\Column(length: 255, nullable: true)]
  97.     private ?string $firstName  = null;
  99.     #[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', 'job:read'])]
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     private ?string $lastName = null;
  103.     #[Groups(['user:read', 'user:create', 'user:update', 'account:read'])]
  104.     #[ORM\Column(length: 100, nullable: true)]
  105.     private ?string $phone = null;
  107.     #[Groups(['user:read', 'user:create', 'user:update'])]
  108.     #[ORM\Column(length: 255, nullable: true)]
  109.     private ?string $address = null; 
  111.     #[Groups(['user:read', 'user:create', 'user:update'])]
  112.     #[ORM\Column(length: 50, nullable: true)]
  113.     private ?string $status = null;
  115.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserLikeList::class)]
  116.     private Collection $userLikeLists;
  118.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: Products::class)]
  119.     private Collection $products;
  121.     #[ORM\OneToMany(mappedBy: 'created_by', targetEntity: Products::class)]
  122.     private Collection $create_products;
  124.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Orders::class)]
  125.     private Collection $orders;
  127.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Orders::class)]
  128.     private Collection $managerOrders;
  130.     #[Groups(['user:read', 'user:create', 'user:update', 'read', 'account:read'])]
  131.     #[ORM\Column(length: 255, nullable: true)]
  132.     private ?string $email = null;
  134.     #[Groups(['user:read', 'user:create', 'user:update', 'read'])]
  135.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Accounts::class)]
  136.     private Collection $accounts;
  138.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: LoadInvoice::class)]
  139.     private Collection $loadInvoices;
  141.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: Accepted::class)]
  142.     private Collection $accepteds;
  144.     #[ORM\OneToMany(mappedBy: 'modified_user', targetEntity: AcceptedProduct::class)]
  145.     private Collection $n;
  147.     #[ORM\Column(length: 20, nullable: true)]
  148.     #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read', 'job:read'])]
  149.     private ?string $codeUser = null;
  151.     #[ORM\Column(length: 20, nullable: true)]
  152.     #[Groups(['user:read', 'user:create', 'user:update', 'order:read', 'order_product:read', 'job: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: 'users', targetEntity: UsersDocs::class)]
  184.     private Collection $usersDocs;
  185.     
  186.     #[ORM\OneToMany(mappedBy: 'manager', targetEntity: ProductBalanceInStorage::class)]
  187.     private Collection $productBalanceInStorages;
  189.     #[Groups(['user:read', 'user:create', 'user:update'])]
  190.     #[ORM\ManyToOne(inversedBy: 'users')]
  191.     private ?Location $location = null;
  193.     #[ORM\OneToMany(mappedBy: 'assigned_user', targetEntity: Jobs::class)]
  194.     private Collection $assigned_jobs;
  196.     #[ORM\OneToMany(mappedBy: 'mainEngineerOp', targetEntity: Jobs::class)]
  197.     private Collection $mainEngineerOp;
  199.     #[Groups(['user:read', 'user:create', 'user:update'])]
  200.     #[ORM\Column(nullable: true)]
  201.     private ?bool $isMainEngineerOp = null;
  205.     public function __construct()
  206.     {
  207.         $this->userLikeLists = new ArrayCollection();
  208.         $this->products = new ArrayCollection();
  209.         $this->create_products = new ArrayCollection();
  210.         $this->orders = new ArrayCollection();
  211.         $this->managerOrders = new ArrayCollection();
  212.         $this->accounts = new ArrayCollection();
  213.         $this->loadInvoices = new ArrayCollection();
  214.         $this->accepteds = new ArrayCollection();
  215.         $this->n = new ArrayCollection();
  216.         $this->managerAccounts = new ArrayCollection();
  217.         $this->preOrders = new ArrayCollection();
  218.         $this->ManagerPreOrders = new ArrayCollection();
  219.         $this->mediaObjects = new ArrayCollection();
  220.         $this->coupons = new ArrayCollection();
  221.         $this->usersDocs = new ArrayCollection();
  222.         $this->productBalanceInStorages = new ArrayCollection();
  223.         $this->assigned_jobs = new ArrayCollection();
  224.         $this->mainEngineerOp = new ArrayCollection();
  225.     }
  227.     public function getId(): ?int
  228.     {
  229.         return $this->id;
  230.     }
  232.     /**
  233.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  234.      */
  235.     public function getUsername(): string
  236.     {
  237.         return (string) $this->username;
  238.     }
  240.     public function setUsername(string $username): self
  241.     {
  242.         $this->username = $username;
  244.         return $this;
  245.     }
  247.     /**
  248.      * A visual identifier that represents this user.
  249.      *
  250.      * @see UserInterface
  251.      */
  252.     public function getUserIdentifier(): string
  253.     {
  254.         return (string) $this->username;
  255.     }
  257.     /**
  258.      * @see UserInterface
  259.      */
  260.     public function getRoles(): array
  261.     {
  262.         $roles = $this->roles;
  263.         // guarantee every user at least has ROLE_USER
  264.         $roles[] = 'ROLE_USER';
  266.         return array_unique($roles);
  267.     }
  269.     public function setRoles(array $roles): self
  270.     {
  271.         $this->roles = $roles;
  273.         return $this;
  274.     }
  276.     /**
  277.      * @see PasswordAuthenticatedUserInterface
  278.      */
  279.     public function getPassword(): string
  280.     {
  281.         return $this->password;
  282.     }
  284.     public function setPassword(string $password): self
  285.     {
  286.         $this->password = $password;
  288.         return $this;
  289.     }
  291.     public function getPlainPassword(): ?string
  292.     {
  293.         return $this->plainPassword;
  294.     }
  296.     public function setPlainPassword(?string $plainPassword): self
  297.     {
  298.         $this->plainPassword = $plainPassword;
  300.         return $this;
  301.     }
  303.     /**
  304.      * Returning a salt is only needed, if you are not using a modern
  305.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  306.      *
  307.      * @see UserInterface
  308.      */
  309.     public function getSalt(): ?string
  310.     {
  311.         return null;
  312.     }
  314.     /**
  315.      * @see UserInterface
  316.      */
  317.     public function eraseCredentials()
  318.     {
  319.         // If you store any temporary, sensitive data on the user, clear it here
  320.         $this->plainPassword = null;
  321.     }
  323.     public function getManagerId(): ?self
  324.     {
  325.         return $this->manager;
  326.     }
  328.     public function setManagerId(?self $manager): self
  329.     {
  330.         $this->manager = $manager;
  332.         return $this;
  333.     }
  334.     
  335.     public function getFirstName(): ?string
  336.     {
  337.         return $this->firstName;
  338.     }
  341.     public function setFirstName(string $firstName): self
  342.     {
  343.         $this->firstName = $firstName;
  345.         return $this;
  346.     }
  348.     public function getLastName(): ?string
  349.     {
  350.         return $this->lastName;
  351.     }
  353.     public function setLastName(string $lastName): self
  354.     {
  355.         $this->lastName = $lastName;
  357.         return $this;
  358.     }
  360.     public function getPhone(): ?string
  361.     {
  362.         return $this->phone;
  363.     }
  365.     public function setPhone(?string $phone): self
  366.     {
  367.         $this->phone = $phone;
  369.         return $this;
  370.     }
  372.     public function getAddress(): ?string
  373.     {
  374.         return $this->address;
  375.     }
  377.     public function setAddress(?string $address): self
  378.     {
  379.         $this->address = $address;
  381.         return $this;
  382.     }
  384.     public function getStatus(): ?string
  385.     {
  386.         return $this->status;
  387.     }
  389.     public function setStatus(?string $status): self
  390.     {
  391.         $this->status = $status;
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection<int, UserLikeList>
  398.      */
  399.     public function getUserLikeLists(): Collection
  400.     {
  401.         return $this->userLikeLists;
  402.     }
  404.     public function addUserLikeList(UserLikeList $userLikeList): self
  405.     {
  406.         if (!$this->userLikeLists->contains($userLikeList)) {
  407.             $this->userLikeLists->add($userLikeList);
  408.             $userLikeList->setUserId($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeUserLikeList(UserLikeList $userLikeList): self
  415.     {
  416.         if ($this->userLikeLists->removeElement($userLikeList)) {
  417.             // set the owning side to null (unless already changed)
  418.             if ($userLikeList->getUserId() === $this) {
  419.                 $userLikeList->setUserId(null);
  420.             }
  421.         }
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return Collection<int, Products>
  428.      */
  429.     public function getProducts(): Collection
  430.     {
  431.         return $this->products;
  432.     }
  434.     public function addProduct(Products $product): self
  435.     {
  436.         if (!$this->products->contains($product)) {
  437.             $this->products->add($product);
  438.             $product->setModifiedUserId($this);
  439.         }
  441.         return $this;
  442.     }
  444.     // public function removeProduct(Products $product): self
  445.     // {
  446.     //     if ($this->products->removeElement($product)) {
  447.     //         // set the owning side to null (unless already changed)
  448.     //         if ($product->getModifiedUserId() === $this) {
  449.     //             $product->setModifiedUserId(null);
  450.     //         }
  451.     //     }
  453.     //     return $this;
  454.     // }
  456.     /**
  457.      * @return Collection<int, Products>
  458.      */
  459.     public function getCreateProducts(): Collection
  460.     {
  461.         return $this->create_products;
  462.     }
  464.     public function addCreateProduct(Products $createProduct): self
  465.     {
  466.         if (!$this->create_products->contains($createProduct)) {
  467.             $this->create_products->add($createProduct);
  468.             $createProduct->setCreatedBy($this);
  469.         }
  471.         return $this;
  472.     }
  474.     // public function removeCreateProduct(Products $createProduct): self
  475.     // {
  476.     //     if ($this->create_products->removeElement($createProduct)) {
  477.     //         // set the owning side to null (unless already changed)
  478.     //         if ($createProduct->getCreatedBy() === $this) {
  479.     //             $createProduct->setCreatedBy(null);
  480.     //         }
  481.     //     }
  483.     //     return $this;
  484.     // }
  486.     /**
  487.      * @return Collection<int, Orders>
  488.      */
  489.     public function getOrders(): Collection
  490.     {
  491.         return $this->orders;
  492.     }
  494.     public function addOrder(Orders $order): self
  495.     {
  496.         if (!$this->orders->contains($order)) {
  497.             $this->orders->add($order);
  498.             $order->setUserId($this);
  499.         }
  501.         return $this;
  502.     }
  504.     // public function removeOrder(Orders $order): self
  505.     // {
  506.     //     if ($this->orders->removeElement($order)) {
  507.     //         // set the owning side to null (unless already changed)
  508.     //         if ($order->getUserId() === $this) {
  509.     //             $order->setUserId(null);
  510.     //         }
  511.     //     }
  513.     //     return $this;
  514.     // }
  516.     /**
  517.      * @return Collection<int, Orders>
  518.      */
  519.     public function getManagerOrders(): Collection
  520.     {
  521.         return $this->managerOrders;
  522.     }
  524.     public function addManagerOrder(Orders $managerOrder): self
  525.     {
  526.         if (!$this->managerOrders->contains($managerOrder)) {
  527.             $this->managerOrders->add($managerOrder);
  528.             $managerOrder->setManagerId($this);
  529.         }
  531.         return $this;
  532.     }
  534.     // public function removeManagerOrder(Orders $managerOrder): self
  535.     // {
  536.     //     if ($this->managerOrders->removeElement($managerOrder)) {
  537.     //         // set the owning side to null (unless already changed)
  538.     //         if ($managerOrder->getManagerId() === $this) {
  539.     //             $managerOrder->setManagerId(null);
  540.     //         }
  541.     //     }
  543.     //     return $this;
  544.     // }
  546.     public function getEmail(): ?string
  547.     {
  548.         return $this->email;
  549.     }
  551.     public function setEmail(?string $email): self
  552.     {
  553.         $this->email = $email;
  555.         return $this;
  556.     }
  558.     /**
  559.      * @return Collection<int, Accounts>
  560.      */
  561.     public function getAccounts(): Collection
  562.     {
  563.         return $this->accounts;
  564.     }
  566.     public function addAccount(Accounts $account): self
  567.     {
  568.         if (!$this->accounts->contains($account)) {
  569.             $this->accounts->add($account);
  570.             $account->setUserId($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeAccount(Accounts $account): self
  577.     {
  578.         if ($this->accounts->removeElement($account)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($account->getUserId() === $this) {
  581.                 $account->setUserId(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     /**
  589.      * @return Collection<int, LoadInvoice>
  590.      */
  591.     public function getLoadInvoices(): Collection
  592.     {
  593.         return $this->loadInvoices;
  594.     }
  596.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  597.     {
  598.         if (!$this->loadInvoices->contains($loadInvoice)) {
  599.             $this->loadInvoices->add($loadInvoice);
  600.             $loadInvoice->setClient($this);
  601.         }
  603.         return $this;
  604.     }
  606.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  607.     {
  608.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($loadInvoice->getClient() === $this) {
  611.                 $loadInvoice->setClient(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     /**
  619.      * @return Collection<int, Accepted>
  620.      */
  621.     public function getAccepteds(): Collection
  622.     {
  623.         return $this->accepteds;
  624.     }
  626.     public function addAccepted(Accepted $accepted): self
  627.     {
  628.         if (!$this->accepteds->contains($accepted)) {
  629.             $this->accepteds->add($accepted);
  630.             $accepted->setManager($this);
  631.         }
  633.         return $this;
  634.     }
  636.     public function removeAccepted(Accepted $accepted): self
  637.     {
  638.         if ($this->accepteds->removeElement($accepted)) {
  639.             // set the owning side to null (unless already changed)
  640.             if ($accepted->getManager() === $this) {
  641.                 $accepted->setManager(null);
  642.             }
  643.         }
  645.         return $this;
  646.     }
  648.     /**
  649.      * @return Collection<int, AcceptedProduct>
  650.      */
  651.     public function getN(): Collection
  652.     {
  653.         return $this->n;
  654.     }
  656.     public function addN(AcceptedProduct $n): self
  657.     {
  658.         if (!$this->n->contains($n)) {
  659.             $this->n->add($n);
  660.             $n->setModifiedUser($this);
  661.         }
  663.         return $this;
  664.     }
  666.     public function removeN(AcceptedProduct $n): self
  667.     {
  668.         if ($this->n->removeElement($n)) {
  669.             // set the owning side to null (unless already changed)
  670.             if ($n->getModifiedUser() === $this) {
  671.                 $n->setModifiedUser(null);
  672.             }
  673.         }
  675.         return $this;
  676.     }
  678.     public function getCodeUser(): ?string
  679.     {
  680.         return $this->codeUser;
  681.     }
  683.     public function setCodeUser(string $codeUser): self
  684.     {
  685.         $this->codeUser = $codeUser;
  687.         return $this;
  688.     }
  690.     public function getCodeManager(): ?string
  691.     {
  692.         return $this->codeManager;
  693.     }
  695.     public function setCodeManager(string $codeManager): self
  696.     {
  697.         $this->codeManager = $codeManager;
  699.         return $this;
  700.     }
  702.     /**
  703.      * @return Collection<int, Accounts>
  704.      */
  705.     public function getManagerAccounts(): Collection
  706.     {
  707.         return $this->managerAccounts;
  708.     }
  710.     public function addManagerAccount(Accounts $managerAccount): self
  711.     {
  712.         if (!$this->managerAccounts->contains($managerAccount)) {
  713.             $this->managerAccounts->add($managerAccount);
  714.             $managerAccount->setManager($this);
  715.         }
  717.         return $this;
  718.     }
  720.     public function removeManagerAccount(Accounts $managerAccount): self
  721.     {
  722.         if ($this->managerAccounts->removeElement($managerAccount)) {
  723.             // set the owning side to null (unless already changed)
  724.             if ($managerAccount->getManager() === $this) {
  725.                 $managerAccount->setManager(null);
  726.             }
  727.         }
  729.         return $this;
  730.     }
  732.     /**
  733.      * @return Collection<int, PreOrder>
  734.      */
  735.     public function getPreOrders(): Collection
  736.     {
  737.         return $this->preOrders;
  738.     }
  740.     public function addPreOrder(PreOrder $preOrder): self
  741.     {
  742.         if (!$this->preOrders->contains($preOrder)) {
  743.             $this->preOrders->add($preOrder);
  744.             $preOrder->setClient($this);
  745.         }
  747.         return $this;
  748.     }
  750.     public function removePreOrder(PreOrder $preOrder): self
  751.     {
  752.         if ($this->preOrders->removeElement($preOrder)) {
  753.             // set the owning side to null (unless already changed)
  754.             if ($preOrder->getClient() === $this) {
  755.                 $preOrder->setClient(null);
  756.             }
  757.         }
  759.         return $this;
  760.     }
  762.     /**
  763.      * @return Collection<int, PreOrder>
  764.      */
  765.     public function getManagerPreOrders(): Collection
  766.     {
  767.         return $this->ManagerPreOrders;
  768.     }
  770.     public function addManagerPreOrder(PreOrder $managerPreOrder): self
  771.     {
  772.         if (!$this->ManagerPreOrders->contains($managerPreOrder)) {
  773.             $this->ManagerPreOrders->add($managerPreOrder);
  774.             $managerPreOrder->setManager($this);
  775.         }
  777.         return $this;
  778.     }
  780.     public function removeManagerPreOrder(PreOrder $managerPreOrder): self
  781.     {
  782.         if ($this->ManagerPreOrders->removeElement($managerPreOrder)) {
  783.             // set the owning side to null (unless already changed)
  784.             if ($managerPreOrder->getManager() === $this) {
  785.                 $managerPreOrder->setManager(null);
  786.             }
  787.         }
  789.         return $this;
  790.     }
  792.     public function getWorkSchedule(): ?string
  793.     {
  794.         return $this->workSchedule;
  795.     }
  797.     public function setWorkSchedule(?string $workSchedule): self
  798.     {
  799.         $this->workSchedule = $workSchedule;
  801.         return $this;
  802.     }
  804.     public function getTelegram(): ?string
  805.     {
  806.         return $this->telegram;
  807.     }
  809.     public function setTelegram(?string $telegram): self
  810.     {
  811.         $this->telegram = $telegram;
  813.         return $this;
  814.     }
  816.     public function getViber(): ?string
  817.     {
  818.         return $this->viber;
  819.     }
  821.     public function setViber(?string $viber): self
  822.     {
  823.         $this->viber = $viber;
  825.         return $this;
  826.     }
  828.     /**
  829.      * @return Collection<int, MediaObject>
  830.      */
  831.     public function getMediaObjects(): Collection
  832.     {
  833.         return $this->mediaObjects;
  834.     }
  836.     public function addMediaObject(MediaObject $mediaObject): self
  837.     {
  838.         if (!$this->mediaObjects->contains($mediaObject)) {
  839.             $this->mediaObjects->add($mediaObject);
  840.             $mediaObject->setUsers($this);
  841.         }
  843.         return $this;
  844.     }
  846.     public function removeMediaObject(MediaObject $mediaObject): self
  847.     {
  848.         if ($this->mediaObjects->removeElement($mediaObject)) {
  849.             // set the owning side to null (unless already changed)
  850.             if ($mediaObject->getUsers() === $this) {
  851.                 $mediaObject->setUsers(null);
  852.             }
  853.         }
  855.         return $this;
  856.     }
  858.     /**
  859.      * @return Collection<int, Coupons>
  860.      */
  861.     public function getCoupons(): Collection
  862.     {
  863.         return $this->coupons;
  864.     }
  866.     public function addCoupon(Coupons $coupon): self
  867.     {
  868.         if (!$this->coupons->contains($coupon)) {
  869.             $this->coupons->add($coupon);
  870.             $coupon->addUser($this);
  871.         }
  873.         return $this;
  874.     }
  876.     public function removeCoupon(Coupons $coupon): self
  877.     {
  878.         if ($this->coupons->removeElement($coupon)) {
  879.             $coupon->removeUser($this);
  880.         }
  882.         return $this;
  883.     }
  885.     /**
  886.      * @return Collection<int, UsersDocs>
  887.      */
  888.     public function getUsersDocs(): Collection
  889.     {
  890.         return $this->usersDocs;
  891.     }
  893.     public function addUsersDoc(UsersDocs $usersDoc): static
  894.     {
  895.         if (!$this->usersDocs->contains($usersDoc)) {
  896.             $this->usersDocs->add($usersDoc);
  897.             $usersDoc->setUsers($this);
  898.         }
  899.         return $this;
  900.     }
  901.     
  902.     /**
  903.      * @return Collection<int, ProductBalanceInStorage>
  904.      */
  905.     public function getProductBalanceInStorages(): Collection
  906.     {
  907.         return $this->productBalanceInStorages;
  908.     }
  910.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  911.     {
  912.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  913.             $this->productBalanceInStorages->add($productBalanceInStorage);
  914.             $productBalanceInStorage->setManager($this);
  915.         }
  917.         return $this;
  918.     }
  920.     public function removeUsersDoc(UsersDocs $usersDoc): static
  921.     {
  922.         if ($this->usersDocs->removeElement($usersDoc)) {
  923.             // set the owning side to null (unless already changed)
  924.             if ($usersDoc->getUsers() === $this) {
  925.                 $usersDoc->setUsers(null);
  926.             }
  927.         }
  928.         return $this;
  929.     }
  931.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  932.     {
  933.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  934.             // set the owning side to null (unless already changed)
  935.             if ($productBalanceInStorage->getManager() === $this) {
  936.                 $productBalanceInStorage->setManager(null);
  937.             }
  938.         }
  940.         return $this;
  941.     }
  943.     public function getLocation(): ?Location
  944.     {
  945.         return $this->location;
  946.     }
  948.     public function setLocation(?Location $location): self
  949.     {
  950.         $this->location = $location;
  952.         return $this;
  953.     }
  955.     /**
  956.      * @return Collection<int, Jobs>
  957.      */
  958.     public function getAssignedJobs(): Collection
  959.     {
  960.         return $this->assigned_jobs;
  961.     }
  963.     public function addAssignedJob(Jobs $assignedJob): self
  964.     {
  965.         if (!$this->assigned_jobs->contains($assignedJob)) {
  966.             $this->assigned_jobs->add($assignedJob);
  967.             $assignedJob->setAssignedUser($this);
  968.         }
  970.         return $this;
  971.     }
  973.     public function removeAssignedJob(Jobs $assignedJob): self
  974.     {
  975.         if ($this->assigned_jobs->removeElement($assignedJob)) {
  976.             // set the owning side to null (unless already changed)
  977.             if ($assignedJob->getAssignedUser() === $this) {
  978.                 $assignedJob->setAssignedUser(null);
  979.             }
  980.         }
  982.         return $this;
  983.     }
  985.     /**
  986.      * @return Collection<int, Jobs>
  987.      */
  988.     public function getMainEngineerOp(): Collection
  989.     {
  990.         return $this->mainEngineerOp;
  991.     }
  993.     public function addMainEngineerOp(Jobs $mainEngineerOp): static
  994.     {
  995.         if (!$this->mainEngineerOp->contains($mainEngineerOp)) {
  996.             $this->mainEngineerOp->add($mainEngineerOp);
  997.             $mainEngineerOp->setMainEngineerOp($this);
  998.         }
  1000.         return $this;
  1001.     }
  1003.     public function removeMainEngineerOp(Jobs $mainEngineerOp): static
  1004.     {
  1005.         if ($this->mainEngineerOp->removeElement($mainEngineerOp)) {
  1006.             // set the owning side to null (unless already changed)
  1007.             if ($mainEngineerOp->getMainEngineerOp() === $this) {
  1008.                 $mainEngineerOp->setMainEngineerOp(null);
  1009.             }
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function isIsMainEngineerOp(): ?bool
  1016.     {
  1017.         return $this->isMainEngineerOp;
  1018.     }
  1020.     public function setIsMainEngineerOp(?bool $isMainEngineerOp): static
  1021.     {
  1022.         $this->isMainEngineerOp = $isMainEngineerOp;
  1024.         return $this;
  1025.     }
  1027. }