1. <?php
3. namespace App\Entity;
5. use ApiPlatform\Metadata\ApiResource;
6. use App\Repository\ProductsRepository;
7. use Doctrine\Common\Collections\ArrayCollection;
8. use Doctrine\Common\Collections\Collection;
9. use Doctrine\DBAL\Types\Types;
10. use Doctrine\ORM\Mapping as ORM;
11. use Symfony\Component\Security\Core\Security;
12. use Symfony\Component\Security\Core\SecurityInterface;
13. use DateTimeImmutable;
14. use ApiPlatform\Metadata\ApiFilter;
15. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
16. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\BooleanFilter;
17. use ApiPlatform\Metadata\Get;
18. use ApiPlatform\Metadata\GetCollection;
19. use ApiPlatform\Metadata\Delete;
20. use ApiPlatform\Metadata\Put;
21. use ApiPlatform\Metadata\Post;
22. use App\Controller\BatchCreateProductAction;
23. use App\Controller\ProductController;
24. use Symfony\Component\Serializer\Annotation\Groups;
25. use ApiPlatform\Core\Annotation\ApiProperty; 
26. use Symfony\Component\Serializer\Annotation\MaxDepth;
27. use App\Filter\ShowProductsFilter;
28. use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
29. use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
30. use App\Filter\CustomOrFilter; 
31. use App\Filter\AttributeFilter; 
32. use App\Filter\DeletedFilter; 
33. use Doctrine\ORM\Mapping\Index;
34. use ApiPlatform\Serializer\Filter\GroupFilter;
35. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\ExistsFilter;
38. #[ORM\Entity(repositoryClass: ProductsRepository::class)]
39. #[ApiResource(
40.     operations: [
41.         new Get(),
42.         new Post(),
43.         new Delete(),
44.         new GetCollection(),
45.         new Put(),
46.         new Post(
47.             name: 'batch', 
48.             uriTemplate: '/products/batch', 
49.             controller: BatchCreateProductAction::class
50.         ),
51.         new Get(
52.             name: 'filter_product', 
53.             uriTemplate: '/products/filter', 
54.             controller: ProductController::class
55.         )
56.     ],
57.     normalizationContext: ['groups' => ['product:read', 'prod:medium']],
58.     denormalizationContext: ['groups' => ['product:write']],
59.     order: ['name' => 'ASC', 'media.sort' => 'DESC', 'discontinued' => 'DESC'],
60.     // paginationPartial: true,
61.     // paginationEnabled: true,
62.     // filters: [ShowProductsFilter::class] 
63. )]
64. // #[Get]
65. #[ORM\HasLifecycleCallbacks]
67. #[ApiFilter(RangeFilter::class, properties: ['balance', 'price'])]
69. #[ApiFilter(DeletedFilter::class)]
71. #[ApiFilter(
72.     SearchFilter::class, 
73.     properties: [
74.         'id' => 'exact', 
75.         'oldCode' => 'exact', 
76.         'code1c' => 'exact', 
77.         'top' => 'exact', 
78.         'productToOrder' => 'exact', 
79.         'name' => 'ipartial', 
80.         'barcode' => 'exact', 
81.         'category.id' => 'exact',
82.         'category.slug' => 'exact',
83.         'category.type' => 'exact',
84.         'attributeItems.id' => 'exact',
85.         'show' => 'exact',
86.         'article' => 'exact',
87.         'prices.product' => 'exact',
88.         'prices.agreement.virtual' => 'exact',
89.         'prices.agreement.account.id' => 'exact',
90.         'productBalanceInStorages.manager.id' => 'exact',
91.         'orderProducts.order.account.id' => 'exact',
92.         'orderProducts.order.account.user.id' => 'exact',
93.         'categoryCnt' => 'exact',
94.         'deleted' => 'exact',
95.         'isSalle' => 'exact',
96.         'isNew' => 'exact',
97.         'isTop' => 'exact',
98.         'category.slug' => 'exact',
99.         'translation' => 'exact',
100.         'language' => 'exact',
101.         'discontinued' => 'exact',
102.     ],
103. )]
105. #[ApiFilter(AttributeFilter::class)]
107. #[ApiFilter(OrderFilter::class, properties: ['price', 'name'], arguments: ['orderParameterName' => 'order'])]
109. #[Index(name: "show", columns: ["show", "deleted"])]
111. #[ApiFilter(GroupFilter::class, arguments: ['parameterName' => 'g', 'overrideDefaultGroups' => true])]
113. #[ApiFilter(ExistsFilter::class, properties: ['attributeItems'])]
115. class Products
116. {
117.     #[ORM\Id]
118.     #[ORM\GeneratedValue]
119.     #[ORM\Column]
120.     #[Groups(['product:read', 'product:admin', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
121.     private ?int $id = null;
123.     #[ORM\Column(length: 255)]
124.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
125.     private ?string $name = null;
127.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
128.     #[Groups(['product:admin'])]
129.     private ?\DateTimeInterface $date_entered;
131.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
132.     #[Groups(['product:admin'])]
133.     private ?\DateTimeInterface $date_modified;
135.     #[ORM\ManyToOne(inversedBy: 'products')]
136.     #[Groups(['product:modified_user'])]
137.     #[MaxDepth(1)]
138.     private ?User $modified_user = null;
140.     #[ORM\ManyToOne(inversedBy: 'create_products')]
141.     #[Groups(['product:created_by'])]
142.     #[MaxDepth(1)]
143.     private ?User $created_by;
145.     #[Groups(['product:read', 'product:write', 'site_product:read'])]
146.     #[ORM\Column(type: Types::TEXT, nullable: true)]
147.     private ?string $description = null;
149.     #[ORM\Column(length: 20, nullable: true)]
150.     #[Groups([ 'product:admin', 'product:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read'])]
151.     private ?string $code1c = null;
153.     #[ORM\Column(length: 100, nullable: true)]
154.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
155.     private ?string $barcode = null;
157.     #[ORM\Column(length: 100, nullable: true)]
158.     #[Groups(['product:read', 'product:write'])]
159.     private ?string $status = null;
161.     #[ORM\Column(nullable: true)]
162.     #[Groups(['product:read', 'product:write', 'order_product:read', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
163.     private ?float $price = null;
165.     #[ORM\Column(nullable: true)]
166.     #[Groups([ 'product:admin', 'product:write', 'order_product:read', 'product_releted:read'])]
167.     private ?float $priceIncome = null;
169.     #[ORM\Column(nullable: true)]
170.     #[Groups(['product:admin', 'product:write'])]
171.     private ?float $mark_up = null;
173.     #[ORM\Column]
174.     #[Groups(['product:admin', 'product:write'])]
175.     private ?float $min_mark_up = 1;
177.     #[ORM\Column(length: 100, nullable: true)]
178.     #[Groups(['product:write'])]
179.     private ?string $packing_type = null;
181.     #[ORM\Column(nullable: true)]
182.     #[Groups(['product:write'])]
183.     private ?float $packing_type_count = null;
185.     #[ORM\Column(nullable: true)]
186.     #[Groups(['product:read', 'product:write', 'order_product:read', 'product_releted:read'])]
187.     private ?int $discounts = null;
189.     #[ORM\Column(nullable: true)]
190.     #[Groups(['product:admin', 'product:write'])]
191.     private ?int $count_order = null;
193.     #[ORM\Column(nullable: true)]
194.     #[Groups(['product:read', 'product:write'])]
195.     private ?int $productToOrder = null;
197.     #[ORM\ManyToOne]
198.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read'])]
199.     #[ApiProperty(writable: true)]
200.     #[MaxDepth(1)]
201.     private ?MeasurmentUnit $measurement_unit = null;
203.     #[Groups(['product:productInfos', 'product:write', 'site_product:read'])]
204.     #[MaxDepth(1)]
205.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductInfo::class,)]
206.     private ?Collection $productInfos = null;
208.     #[MaxDepth(1)]
209.     #[Groups(['product:media', 'product:write', 'cat:read', 'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
210.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: MediaObject::class)]
211.     private Collection $media;
213.     #[MaxDepth(2)]
214.     #[Groups(['product:incomingInvoiceProducts', 'product:write'])]
215.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: IncomingInvoiceProduct::class)]
216.     private Collection $incomingInvoiceProducts;
217.     
218.     private ?SecurityInterface $security = null;
220.     #[ORM\Column(length: 20, nullable: true)]
221.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
222.     private ?string $article = null;
224.     #[ORM\Column(nullable: true)]
225.     #[Groups(['product:admin', 'product:write'])]
226.     private ?float $nds = null;
228.     #[ORM\Column(nullable: true)]
229.     #[Groups(['product:admin', 'product:write'])]
230.     private ?bool $service = null;
232.     #[ORM\Column(nullable: true)]
233.     #[Groups(['product:admin', 'product:write'])]
234.     private ?bool $transport_service = null;
236.     #[ORM\Column(nullable: true)]
237.     #[Groups(['product:read', 'product:write'])]
238.     private ?bool $exise = false;
240.     #[ORM\Column(nullable: true)]
241.     #[Groups(['product:read', 'product:write'])]
242.     private ?bool $expiration_date = null;
244.     #[ORM\Column(nullable: true)]
245.     #[Groups(['product:read', 'product:write'])]
246.     private ?float $unit_volume = null;
248.     #[ORM\Column(nullable: true)]
249.     #[Groups(['product:read', 'product:write'])]
250.     private ?float $net_weight = null;
252.     #[ORM\Column(nullable: true)]
253.     #[Groups(['product:read', 'product:write'])]
254.     private ?float $gross_weight = null;
256.     #[ORM\Column(nullable: true)]
257.     #[Groups(['product:read', 'product:write'])]
258.     private ?bool $go_by_weight = null;
260.     #[ORM\Column(nullable: true)]
261.     #[Groups(['product:read', 'product:write'])]
262.     private ?float $packaging = null;
264.     #[ORM\ManyToOne(inversedBy: 'products')]
265.     #[MaxDepth(1)]
266.     #[Groups(['product:siteProduct', 'product:write'])]
267.     private ?SiteProducts $siteProduct = null;
269.     #[Groups([ 'product:category', 'product:write'])]
270.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
271.     #[MaxDepth(1)]
272.     private Collection $category;
273.     
274.     #[Groups(['product:admin', 'product:write'])]
275.     #[ORM\Column(length: 100, nullable: true)]
276.     private ?string $oldCode = null;
278.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: UserLikeList::class)]
279.     private Collection $userLikeLists;
281.     #[Groups(['product:attributeItems', 'product:write', 'site_product:read'])]
282.     #[ORM\ManyToMany(targetEntity: AttributeItems::class, mappedBy: 'product')] 
283.     private Collection $attributeItems;
286.     #[Groups([ 'product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
287.     #[ORM\Column(nullable: true)]
288.     private ?bool $show = null;
290.     #[Groups(['product:storage', 'product:write', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
291.     #[ORM\ManyToOne(inversedBy: 'products')]
292.     private ?Storage $storage = null;
294.     #[MaxDepth(2)]
295.     #[Groups(['product:storageElement', 'product:write','order:read', 'order_product:read'])]
296.     #[ORM\ManyToOne(inversedBy: 'products')]
297.     private ?StorageElement $storageElement = null;
299.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Prices::class)]
300.     private Collection $prices;
302.     #[Groups(['product:productBalanceInStorages', 'product:write', 'order_product:read', 'pre_order_product:read'])]
303.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductBalanceInStorage::class)]
304.     private Collection $productBalanceInStorages;
306.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','site_product:read'])]
307.     #[ORM\Column(nullable: true)]
308.     private ?float $balance = null;
310.     #[ApiProperty(writable: true)]
311.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderProduct::class)]
312.     private Collection $orderProducts;
314.     #[Groups(['product:language', 'product:write'])]
315.     #[ORM\ManyToOne(inversedBy: 'products')]
316.     #[MaxDepth(1)]
317.     private ?Languages $language = null;
319.     #[MaxDepth(1)]
320.     #[Groups(['product:read', 'product:write', 'cat:read', 'attributes_items:read', 'attributes:read'])]
321.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'translations')]
322.     private ?self $translation = null;
324.     #[MaxDepth(1)]
325.     #[Groups(['product:read'])]
326.     #[ORM\OneToMany(mappedBy: 'translation', targetEntity: self::class)]
327.     private Collection $translations;
329.     #[Groups(['product:read', 'product:write', 'cat:read', 'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read', 'product_releted:read'])]
330.     #[ORM\ManyToOne(inversedBy: 'MainProducts')]
331.     private ?MediaObject $mainMedia = null;
333.     #[Groups(['product:admin', 'product:write'])]
334.     #[ORM\Column(nullable: true, options: ["default" => false])]
335.     private ?bool $deleted = false;
337.     #[Groups(['product:admin', 'product:write'])]
338.     #[ORM\Column(nullable: true,  options: ["default" => 0])]
339.     private ?int $categoryCnt = 0;
341.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
342.     #[ORM\Column(nullable: true)]
343.     private ?array $priceCategory = null;
345.     #[Groups(['product:comments', 'product:write'])]
346.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Comments::class)]
347.     private Collection $comments;
349.     #[Groups(['product:read', 'product:write'])]
350.     #[ORM\Column(nullable: true)]
351.     private ?bool $isSalle = null;
353.     #[Groups(['product:read', 'product:write'])]
354.     #[ORM\Column(nullable: true)]
355.     private ?bool $isNew = null;
357.     #[Groups(['product:read', 'product:write'])]
358.     #[ORM\Column(nullable: true)]
359.     private ?bool $isTop = null;
361.     #[Groups(['product:hover', 'product:write', 'product_releted:read'])]
362.     #[ORM\ManyToOne(inversedBy: 'productsHover')]
363.     private ?MediaObject $mainMediaHover = null;
365.     #[Groups(['productsReleteds:read', 'product:write'])]
366.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductsReleted::class)]
367.     private Collection $productsReleteds;
369.     #[ORM\OneToMany(mappedBy: 'relatedProduct', targetEntity: ProductsReleted::class)]
370.     private Collection $parentProductRelateds;
372.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
373.     #[ORM\Column(nullable: true)]
374.     private ?float $oldPrice = null;
376.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
377.     #[ORM\Column(nullable: true)]
378.     private ?int $discountPercent = null;
380.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
381.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
382.     private ?\DateTimeInterface $dateLastPriceIncome = null;
384.     #[Groups(['product:read', 'product:write'])]
385.     #[ORM\Column(nullable: true)]
386.     private ?array $video = null;
388.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
389.     #[ORM\Column(nullable: true)]
390.     private ?bool $isVideo = null;
392.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
393.     #[ORM\Column(nullable: true)]
394.     private ?bool $isFreeShipping = null;
396.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
397.     #[ORM\Column(length: 255, nullable: true)]
398.     private ?string $warrantyPeriod = null;
400.     #[Groups(['product:read', 'product:write'])]
401.     #[ORM\Column(nullable: true)]
402.     private ?float $minBalance = null;
404.     #[Groups(['product:read', 'product:write'])]
405.     #[ORM\Column(nullable: true)]
406.     private ?float $minBalanceAdmin = null;
407.     
408.     #[Groups(['product:read', 'product:write'])]
409.     #[ORM\Column(nullable: true)]
410.     private ?int $mainCategoryId = null;
412.     #[Groups(['product:read', 'product:write'])]
413.     #[ORM\Column(nullable: true, options: ["default" => false])]
414.     private ?bool $discontinued = null;
416.     /**
417.      * @var Collection<int, Documents>
418.      */
419.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Documents::class)]
420.     private Collection $documents;
422.     public function __construct() {
423.         $this->productInfos = new ArrayCollection();
424.         $this->media = new ArrayCollection();
425.         $this->incomingInvoiceProducts = new ArrayCollection();
426.         $this->category = new ArrayCollection();
427.         // $this->mediaObjects = new ArrayCollection();
428.         $this->userLikeLists = new ArrayCollection();
429.         $this->attributeItems = new ArrayCollection();
430.         $this->prices = new ArrayCollection();
431.         $this->productBalanceInStorages = new ArrayCollection();
432.         $this->orderProducts = new ArrayCollection();
433.         $this->products = new ArrayCollection();
434.         $this->comments = new ArrayCollection();
435.         $this->productsReleteds = new ArrayCollection();
436.         $this->parentProductRelateds = new ArrayCollection();
437.         // $this->mytranslations = new ArrayCollection();
438.         $this->translations = new ArrayCollection();
439.         $this->documents = new ArrayCollection();
441.     }
443.     public function getId(): ?int
444.     {
445.         return $this->id;
446.     }
448.     public function setId(string $id): self
449.     {
450.         $this->id = $id;
452.         return $this;
453.     }
455.     public function getName(): ?string
456.     {
457.         return $this->name;
458.     }
460.     public function setName(string $name): self
461.     {
462.         $this->name = $name;
464.         return $this;
465.     }
467.     public function getDateEntered(): ?\DateTimeInterface
468.     {
469.         return $this->date_entered;
470.     }
472.     // public function setDateEntered(?\DateTimeInterface $date_entered): self
473.     // {
474.     //     $this->date_entered = $date_entered;
476.     //     return $this;
477.     // }
479.     public function getDateModified(): ?\DateTimeInterface
480.     {
481.         return $this->date_modified;
482.     }
484.     // public function setDateModified(?\DateTimeInterface $date_modified): self
485.     // {
486.     //     $this->date_modified = $date_modified;
488.     //     return $this;
489.     // }
491.     public function getModifiedUser(): ?User
492.     {
493.         return $this->modified_user;
494.     }
496.     // public function setModifiedUserId(?User $modified_user_id): self
497.     // {
498.     //     $this->modified_user_id = $modified_user_id;
500.     //     return $this;
501.     // }
503.     public function getCreatedBy(): ?User
504.     {
505.         return $this->created_by;
506.     }
508.     public function setCreatedBy(?User $created_by): self
509.     {
510.         $this->created_by = $created_by;
512.         return $this;
513.     }
515.     public function getDescription(): ?string
516.     {
517.         return $this->description;
518.     }
520.     public function setDescription(?string $description): self
521.     {
522.         $this->description = $description;
524.         return $this;
525.     }
527.     public function getCode1c(): ?string
528.     {
529.         return $this->code1c;
530.     }
532.     public function setCode1c(?string $code1c): self
533.     {
534.         $this->code1c = $code1c;
536.         return $this;
537.     }
539.     public function getBarcode(): ?string
540.     {
541.         return $this->barcode;
542.     }
544.     public function setBarcode(?string $barcode): self
545.     {
546.         $this->barcode = $barcode;
548.         return $this;
549.     }
551.     public function getStatus(): ?string
552.     {
553.         return $this->status;
554.     }
556.     public function setStatus(?string $status): self
557.     {
558.         $this->status = $status;
560.         return $this;
561.     }
563.     public function getPrice(): ?float
564.     {
565.         return $this->price;
566.     }
568.     public function setPrice(?float $price): self
569.     {
570.         $this->price = $price;
572.         return $this;
573.     }
575.     public function getPriceIncome(): ?float
576.     {
577.         return $this->priceIncome;
578.     }
580.     public function setPriceIncome(?float $priceIncome): self
581.     {
582.         $this->priceIncome = $priceIncome;
584.         return $this;
585.     }
587.     public function getMarkUp(): ?float
588.     {
589.         return $this->mark_up;
590.     }
592.     public function setMarkUp(?float $mark_up): self
593.     {
594.         $this->mark_up = $mark_up;
596.         return $this;
597.     }
599.     public function getMinMarkUp(): ?float
600.     {
601.         return $this->min_mark_up;
602.     }
604.     public function setMinMarkUp(float $min_mark_up): self
605.     {
606.         $this->min_mark_up = $min_mark_up;
608.         return $this;
609.     }
611.     public function getPackingType(): ?string
612.     {
613.         return $this->packing_type;
614.     }
616.     public function setPackingType(?string $packing_type): self
617.     {
618.         $this->packing_type = $packing_type;
620.         return $this;
621.     }
623.     public function getPackingTypeCount(): ?float
624.     {
625.         return $this->packing_type_count;
626.     }
628.     public function setPackingTypeCount(?float $packing_type_count): self
629.     {
630.         $this->packing_type_count = $packing_type_count;
632.         return $this;
633.     }
635.     public function getDiscounts(): ?int
636.     {
637.         return $this->discounts;
638.     }
640.     public function setDiscounts(?int $discounts): self
641.     {
642.         $this->discounts = $discounts;
644.         return $this;
645.     }
647.     public function getCountOrder(): ?int
648.     {
649.         return $this->count_order;
650.     }
652.     public function setCountOrder(?int $count_order): self
653.     {
654.         $this->count_order = $count_order;
656.         return $this;
657.     }
659.     public function getProductToOrder(): ?int
660.     {
661.         return $this->productToOrder;
662.     }
664.     public function setProductToOrder(?int $productToOrder): self
665.     {
666.         $this->productToOrder = $productToOrder;
668.         return $this;
669.     }
671.     public function getMeasurementUnit(): ?MeasurmentUnit
672.     {
673.         return $this->measurement_unit;
674.     }
676.     public function setMeasurementUnit(?MeasurmentUnit $measurement_unit_id): self
677.     {
678.         $this->measurement_unit = $measurement_unit_id;
680.         return $this;
681.     }
683.     /**
684.      * @return Collection<int, ProductInfo>
685.      */
686.     public function getProductInfos(): Collection
687.     {
688.         return $this->productInfos;
689.     }
691.     public function addProductInfo(ProductInfo $productInfo): self
692.     {
693.         if (!$this->productInfos->contains($productInfo)) {
694.             $this->productInfos->add($productInfo);
695.             $productInfo->setProduct($this);
696.         }
698.         return $this;
699.     }
701.     public function removeProductInfo(ProductInfo $productInfo): self
702.     {
703.         if ($this->productInfos->removeElement($productInfo)) {
704.             // set the owning side to null (unless already changed)
705.             if ($productInfo->getProduct() === $this) {
706.                 $productInfo->setProduct(null);
707.             }
708.         }
710.         return $this;
711.     }
713.     /**
714.      * @return Collection<int, MediaObject>
715.      */
716.     public function getMedia(): Collection
717.     {
718.         return $this->media;
719.     }
721.     public function addMedium(MediaObject $medium): self
722.     {
723.         if (!$this->media->contains($medium)) {
724.             $this->media->add($medium);
725.             $medium->setProduct($this);
726.         }
728.         return $this;
729.     }
731.     public function removeMedium(MediaObject $medium): self
732.     {
733.         if ($this->media->removeElement($medium)) {
734.             // set the owning side to null (unless already changed)
735.             if ($medium->getProduct() === $this) {
736.                 $medium->setProduct(null);
737.             }
738.         }
740.         return $this;
741.     }
743.     /**
744.      * @return Collection<int, IncomingInvoiceProduct>
745.      */
746.     public function getIncomingInvoiceProducts(): Collection
747.     {
748.         return $this->incomingInvoiceProducts;
749.     }
751.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
752.     {
753.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
754.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
755.             $incomingInvoiceProduct->setProduct($this);
756.         }
758.         return $this;
759.     }
761.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
762.     {
763.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
764.             // set the owning side to null (unless already changed)
765.             if ($incomingInvoiceProduct->getProduct() === $this) {
766.                 $incomingInvoiceProduct->setProduct(null);
767.             }
768.         }
770.         return $this;
771.     }
773.     #[ORM\PrePersist]
774.     public function setCreatedAtValue(): void
775.     {
776.         $this->date_entered = new \DateTime();
777.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', $this->getCurrentUserId() . "\n", FILE_APPEND);
778.         $this->created_by = $this->getCurrentUserId();
779.     }
781.     // #[ORM\PrePersist]
782.     #[ORM\PreUpdate]
783.     public function setUpdatedAtValue(): void
784.     {
785.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', "222222\n", FILE_APPEND);
786.         $this->date_modified = new \DateTime();
787.         $this->modified_user = $this->getCurrentUserId();
788.     }
790.     public function getCurrentUserId(): ?User
791.     {
792.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', print_r($this->security, true)."\n", FILE_APPEND);
793.         if (!$this->security) {
794.             return null;
795.         }
797.         $token = $this->security->getToken();
798.         if (!$token) {
799.             return null;
800.         }
802.         $user = $token->getUser();
803.         if (!$user instanceof User) {
804.             return null;
805.         }
807.         return $user;
808.     }
810.     public function __sleep()
811.     {
812.         return [
813.             'modified_user',
814.             // 'created_by',
815.             // 'date_entered',
816.             'date_modified'
817.         ];
818.     }
820.     public function __wakeup(): void
821.     {
822.         $this->security = null;
823.     }
825.     public function getArticle(): ?string
826.     {
827.         return $this->article;
828.     }
830.     public function setArticle(?string $article): self
831.     {
832.         $this->article = $article;
834.         return $this;
835.     }
837.     public function getNds(): ?float
838.     {
839.         return $this->nds;
840.     }
842.     public function setNds(?float $nds): self
843.     {
844.         $this->nds = $nds;
846.         return $this;
847.     }
849.     public function isService(): ?bool
850.     {
851.         return $this->service;
852.     }
854.     public function setService(?bool $service): self
855.     {
856.         $this->service = $service;
858.         return $this;
859.     }
861.     public function isTransportService(): ?bool
862.     {
863.         return $this->transport_service;
864.     }
866.     public function setTransportService(?bool $transport_service): self
867.     {
868.         $this->transport_service = $transport_service;
870.         return $this;
871.     }
873.     public function isExise(): ?bool
874.     {
875.         return $this->exise;
876.     }
878.     public function setExise(bool $exise): self
879.     {
880.         $this->exise = $exise;
882.         return $this;
883.     }
885.     public function isExpirationDate(): ?bool
886.     {
887.         return $this->expiration_date;
888.     }
890.     public function setExpirationDate(?bool $expiration_date): self
891.     {
892.         $this->expiration_date = $expiration_date;
894.         return $this;
895.     }
897.     public function getUnitVolume(): ?float
898.     {
899.         return $this->unit_volume;
900.     }
902.     public function setUnitVolume(?float $unit_volume): self
903.     {
904.         $this->unit_volume = $unit_volume;
906.         return $this;
907.     }
909.     public function getNetWeight(): ?float
910.     {
911.         return $this->net_weight;
912.     }
914.     public function setNetWeight(?float $net_weight): self
915.     {
916.         $this->net_weight = $net_weight;
918.         return $this;
919.     }
921.     public function getGrossWeight(): ?float
922.     {
923.         return $this->gross_weight;
924.     }
926.     public function setGrossWeight(?float $gross_weight): self
927.     {
928.         $this->gross_weight = $gross_weight;
930.         return $this;
931.     }
933.     public function isGoByWeight(): ?bool
934.     {
935.         return $this->go_by_weight;
936.     }
938.     public function setGoByWeight(?bool $go_by_weight): self
939.     {
940.         $this->go_by_weight = $go_by_weight;
942.         return $this;
943.     }
945.     public function getPackaging(): ?float
946.     {
947.         return $this->packaging;
948.     }
950.     public function setPackaging(?float $packaging): self
951.     {
952.         $this->packaging = $packaging;
954.         return $this;
955.     }
957.     public function getSiteProduct(): ?SiteProducts
958.     {
959.         return $this->siteProduct;
960.     }
962.     public function setSiteProduct(?SiteProducts $siteProduct): self
963.     {
964.         $this->siteProduct = $siteProduct;
966.         return $this;
967.     }
969.     /**
970.      * @return Collection<int, Category>
971.      */
972.     public function getCategory(): Collection
973.     {
974.         return $this->category;
975.     }
977.     public function addCategory(Category $category): self
978.     {
979.         if (!$this->category->contains($category)) {
980.             $this->category->add($category);
981.         }
983.         return $this;
984.     }
986.     public function removeCategory(Category $category): self
987.     {
988.         $this->category->removeElement($category);
990.         return $this;
991.     }
993.     /**
994.      * @return Collection<int, MediaObject>
995.      */
996.     public function getMediaObjects(): Collection
997.     {
998.         return $this->mediaObjects;
999.     }
1001.     public function addMediaObject(MediaObject $mediaObject): self
1002.     {
1003.         if (!$this->mediaObjects->contains($mediaObject)) {
1004.             $this->mediaObjects->add($mediaObject);
1005.             $mediaObject->setProduct($this);
1006.         }
1008.         return $this;
1009.     }
1011.     public function removeMediaObject(MediaObject $mediaObject): self
1012.     {
1013.         if ($this->mediaObjects->removeElement($mediaObject)) {
1014.             // set the owning side to null (unless already changed)
1015.             if ($mediaObject->getProduct() === $this) {
1016.                 $mediaObject->setProduct(null);
1017.             }
1018.         }
1020.         return $this;
1021.     }
1023.     public function getOldCode(): ?string
1024.     {
1025.         return $this->oldCode;
1026.     }
1028.     public function setOldCode(string $oldCode): self
1029.     {
1030.         $this->oldCode = $oldCode;
1032.         return $this;
1033.     }
1035.     /**
1036.      * @return Collection<int, UserLikeList>
1037.      */
1038.     public function getUserLikeLists(): Collection
1039.     {
1040.         return $this->userLikeLists;
1041.     }
1043.     public function addUserLikeList(UserLikeList $userLikeList): self
1044.     {
1045.         if (!$this->userLikeLists->contains($userLikeList)) {
1046.             $this->userLikeLists->add($userLikeList);
1047.             $userLikeList->setз�product($this);
1048.         }
1050.         return $this;
1051.     }
1053.     public function removeUserLikeList(UserLikeList $userLikeList): self
1054.     {
1055.         if ($this->userLikeLists->removeElement($userLikeList)) {
1056.             // set the owning side to null (unless already changed)
1057.             if ($userLikeList->getз�product() === $this) {
1058.                 $userLikeList->setз�product(null);
1059.             }
1060.         }
1062.         return $this;
1063.     }
1065.     /**
1066.      * @return Collection<int, AttributeItems>
1067.      */
1068.     public function getAttributeItems(): Collection
1069.     {
1070.         return $this->attributeItems;
1071.     }
1073.     public function addAttributeItem(AttributeItems $attributeItem): self
1074.     {
1075.         if (!$this->attributeItems->contains($attributeItem)) {
1076.             $this->attributeItems->add($attributeItem);
1077.             $attributeItem->addProduct($this);
1078.         }
1080.         return $this;
1081.     }
1083.     public function removeAttributeItem(AttributeItems $attributeItem): self
1084.     {
1085.         if ($this->attributeItems->removeElement($attributeItem)) {
1086.             $attributeItem->removeProduct($this);
1087.         }
1089.         return $this;
1090.     }
1092.     public function isShow(): ?bool
1093.     {
1094.         return $this->show;
1095.     }
1097.     public function setShow(?bool $show): self
1098.     {
1099.         $this->show = $show;
1101.         return $this;
1102.     }
1104.     public function getStorage(): ?Storage
1105.     {
1106.         return $this->storage;
1107.     }
1109.     public function setStorage(?Storage $storage): self
1110.     {
1111.         $this->storage = $storage;
1113.         return $this;
1114.     }
1116.     public function getStorageElement(): ?StorageElement
1117.     {
1118.         return $this->storageElement;
1119.     }
1121.     public function setStorageElement(?StorageElement $storageElement): self
1122.     {
1123.         $this->storageElement = $storageElement;
1125.         return $this;
1126.     }
1127.     
1128.     /**
1129.      * @return Collection<int, Prices>
1130.      */
1131.     public function getPrices(): Collection
1132.     {
1133.         return $this->prices;
1134.     }
1136.     public function addPrice(Prices $price): static
1137.     {
1138.         if (!$this->prices->contains($price)) {
1139.             $this->prices->add($price);
1140.             $price->setAgreement($this);
1141.         }
1143.         return $this;
1144.     }
1146.     public function removePrice(Prices $price): static
1147.     {
1148.         if ($this->prices->removeElement($price)) {
1149.             // set the owning side to null (unless already changed)
1150.             if ($price->getAgreement() === $this) {
1151.                 $price->setAgreement(null);
1152.             }
1153.         }
1155.         return $this;
1156.     }
1158.     /**
1159.      * @return Collection<int, ProductBalanceInStorage>
1160.      */
1161.     public function getProductBalanceInStorages(): Collection
1162.     {
1163.         return $this->productBalanceInStorages;
1164.     }
1166.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
1167.     {
1168.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
1169.             $this->productBalanceInStorages->add($productBalanceInStorage);
1170.             $productBalanceInStorage->setProduct($this);
1171.         }
1173.         return $this;
1174.     }
1176.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
1177.     {
1178.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
1179.             // set the owning side to null (unless already changed)
1180.             if ($productBalanceInStorage->getProduct() === $this) {
1181.                 $productBalanceInStorage->setProduct(null);
1182.             }
1183.         }
1185.         return $this;
1186.     }
1188.     public function getBalance(): ?float
1189.     {
1190.         return $this->balance;
1191.     }
1193.     public function setBalance(?float $balance): self
1194.     {
1195.         $this->balance = $balance;
1197.         return $this;
1198.     }
1200.     /**
1201.      * @return Collection<int, OrderProduct>
1202.      */
1203.     public function getOrderProducts(): Collection
1204.     {
1205.         return $this->orderProducts;
1206.     }
1208.     public function addOrderProduct(OrderProduct $orderProduct): self
1209.     {
1210.         if (!$this->orderProducts->contains($orderProduct)) {
1211.             $this->orderProducts->add($orderProduct);
1212.             $orderProduct->setOrder($this);
1213.         }
1215.         return $this;
1216.     }
1218.     public function removeOrderProduct(OrderProduct $orderProduct): self
1219.     {
1220.         if ($this->orderProducts->removeElement($orderProduct)) {
1221.             // set the owning side to null (unless already changed)
1222.             if ($orderProduct->getOrder() === $this) {
1223.                 $orderProduct->setOrder(null);
1224.             }
1225.         }
1227.         return $this;
1228.     }
1230.     public function getLanguage(): ?Languages
1231.     {
1232.         return $this->language;
1233.     }
1235.     public function setLanguage(?Languages $language): self
1236.     {
1237.         $this->language = $language;
1239.         return $this;
1240.     }
1244.     public function getTranslation(): ?self
1245.     {
1246.         return $this->translation;
1247.     }
1249.     public function setTranslation(?self $translation): static
1250.     {
1251.         $this->translation = $translation;
1253.         return $this;
1254.     }
1256.     /**
1257.      * @return Collection<int, self>
1258.      */
1259.     public function getTranslations(): Collection
1260.     {
1261.         return $this->translations;
1262.     }
1264.     public function addTranslation(self $translation): static
1265.     {
1266.         if (!$this->translations->contains($translation)) {
1267.             $this->translations->add($translation);
1268.             $translation->setTranslation($this);
1269.         }
1271.         return $this;
1272.     }
1274.     public function removeTranslation(self $translation): static
1275.     {
1276.         if ($this->translations->removeElement($translation)) {
1277.             // set the owning side to null (unless already changed)
1278.             if ($translation->getTranslation() === $this) {
1279.                 $translation->setTranslation(null);
1280.             }
1281.         }
1283.         return $this;
1284.     }
1286.     public function getMainMedia(): ?MediaObject
1287.     {
1288.         return $this->mainMedia;
1289.     }
1291.     public function setMainMedia(?MediaObject $mainMedia): self
1292.     {
1293.         $this->mainMedia = $mainMedia;
1295.         return $this;
1296.     }
1298.     public function isDeleted(): ?bool
1299.     {
1300.         return $this->deleted;
1301.     }
1303.     public function setDeleted(?bool $deleted): static
1304.     {
1305.         $this->deleted = $deleted;
1307.         return $this;
1308.     }
1310.     public function getCategoryCnt(): ?int
1311.     {
1312.         return $this->categoryCnt;
1313.     }
1315.     public function setCategoryCnt(?int $categoryCnt): static
1316.     {
1317.         $this->categoryCnt = $categoryCnt;
1319.         return $this;
1320.     }
1322.     public function getPriceCategory(): ?array
1323.     {
1324.         return $this->priceCategory;
1325.     }
1327.     public function setPriceCategory(?array $priceCategory): static
1328.     {
1329.         $this->priceCategory = $priceCategory;
1331.         return $this;
1332.     }
1334.     /**
1335.      * @return Collection<int, Comments>
1336.      */
1337.     public function getComments(): Collection
1338.     {
1339.         return $this->comments;
1340.     }
1342.     public function addComment(Comments $comment): static
1343.     {
1344.         if (!$this->comments->contains($comment)) {
1345.             $this->comments->add($comment);
1346.             $comment->setProduct($this);
1347.         }
1349.         return $this;
1350.     }
1352.     public function removeComment(Comments $comment): static
1353.     {
1354.         if ($this->comments->removeElement($comment)) {
1355.             // set the owning side to null (unless already changed)
1356.             if ($comment->getProduct() === $this) {
1357.                 $comment->setProduct(null);
1358.             }
1359.         }
1361.         return $this;
1362.     }
1364.     public function isIsSalle(): ?bool
1365.     {
1366.         return $this->isSalle;
1367.     }
1369.     public function setIsSalle(?bool $isSalle): static
1370.     {
1371.         $this->isSalle = $isSalle;
1373.         return $this;
1374.     }
1376.     public function isIsNew(): ?bool
1377.     {
1378.         return $this->isNew;
1379.     }
1381.     public function setIsNew(?bool $isNew): static
1382.     {
1383.         $this->isNew = $isNew;
1385.         return $this;
1386.     }
1388.     public function isIsTop(): ?bool
1389.     {
1390.         return $this->isTop;
1391.     }
1393.     public function setIsTop(?bool $isTop): static
1394.     {
1395.         $this->isTop = $isTop;
1397.         return $this;
1398.     }
1400.     public function getMainMediaHover(): ?MediaObject
1401.     {
1402.         return $this->mainMediaHover;
1403.     }
1405.     public function setMainMediaHover(?MediaObject $mainMediaHover): static
1406.     {
1407.         $this->mainMediaHover = $mainMediaHover;
1409.         return $this;
1410.     }
1412.     /**
1413.      * @return Collection<int, ProductsReleted>
1414.      */
1415.     public function getProductsReleteds(): Collection
1416.     {
1417.         return $this->productsReleteds;
1418.     }
1420.     public function addProductsReleted(ProductsReleted $productsReleted): static
1421.     {
1422.         if (!$this->productsReleteds->contains($productsReleted)) {
1423.             $this->productsReleteds->add($productsReleted);
1424.             $productsReleted->setProduct($this);
1425.         }
1427.         return $this;
1428.     }
1430.     public function removeProductsReleted(ProductsReleted $productsReleted): static
1431.     {
1432.         if ($this->productsReleteds->removeElement($productsReleted)) {
1433.             // set the owning side to null (unless already changed)
1434.             if ($productsReleted->getProduct() === $this) {
1435.                 $productsReleted->setProduct(null);
1436.             }
1437.         }
1439.         return $this;
1440.     }
1442.     /**
1443.      * @return Collection<int, ProductsReleted>
1444.      */
1445.     public function getParentProductRelateds(): Collection
1446.     {
1447.         return $this->parentProductRelateds;
1448.     }
1450.     public function addParentProductRelated(ProductsReleted $parentProductRelated): static
1451.     {
1452.         if (!$this->parentProductRelateds->contains($parentProductRelated)) {
1453.             $this->parentProductRelateds->add($parentProductRelated);
1454.             $parentProductRelated->setRelatedProduct($this);
1455.         }
1457.         return $this;
1458.     }
1460.     public function removeParentProductRelated(ProductsReleted $parentProductRelated): static
1461.     {
1462.         if ($this->parentProductRelateds->removeElement($parentProductRelated)) {
1463.             // set the owning side to null (unless already changed)
1464.             if ($parentProductRelated->getRelatedProduct() === $this) {
1465.                 $parentProductRelated->setRelatedProduct(null);
1466.             }
1467.         }
1469.         return $this;
1470.     }
1472.     public function getOldPrice(): ?float
1473.     {
1474.         return $this->oldPrice;
1475.     }
1477.     public function setOldPrice(?float $oldPrice): static
1478.     {
1479.         $this->oldPrice = $oldPrice;
1481.         return $this;
1482.     }
1484.     public function getDiscountPercent(): ?int
1485.     {
1486.         return $this->discountPercent;
1487.     }
1489.     public function setDiscountPercent(?int $discountPercent): static
1490.     {
1491.         $this->discountPercent = $discountPercent;
1493.         return $this;
1494.     }
1496.     public function getDateLastPriceIncome(): ?\DateTimeInterface
1497.     {
1498.         return $this->dateLastPriceIncome;
1499.     }
1501.     public function setDateLastPriceIncome(?\DateTimeInterface $dateLastPriceIncome): static
1502.     {
1503.         $this->dateLastPriceIncome = $dateLastPriceIncome;
1504.         
1505.         return $this;
1506.     }
1507.     
1508.     public function getVideo(): ?array
1509.     {
1510.         return $this->video;
1511.     }
1513.     public function setVideo(?array $video): static
1514.     {
1515.         $this->video = $video;
1517.         return $this;
1518.     }
1520.     public function isIsVideo(): ?bool
1521.     {
1522.         return $this->isVideo;
1523.     }
1525.     public function setIsVideo(?bool $isVideo): static
1526.     {
1527.         $this->isVideo = $isVideo;
1529.         return $this;
1530.     }
1532.     public function isIsFreeShipping(): ?bool
1533.     {
1534.         return $this->isFreeShipping;
1535.     }
1537.     public function setIsFreeShipping(?bool $isFreeShipping): static
1538.     {
1539.         $this->isFreeShipping = $isFreeShipping;
1541.         return $this;
1542.     }
1544.     public function getWarrantyPeriod(): ?string
1545.     {
1546.         return $this->warrantyPeriod;
1547.     }
1549.     public function setWarrantyPeriod(?string $warrantyPeriod): static
1550.     {
1551.         $this->warrantyPeriod = $warrantyPeriod;
1553.         return $this;
1554.     }
1556.     public function getMinBalance(): ?float
1557.     {
1558.         return $this->minBalance;
1559.     }
1561.     public function setMinBalance(?float $minBalance): static
1562.     {
1563.         $this->minBalance = $minBalance;
1565.         return $this;
1566.     }
1568.     public function getMinBalanceAdmin(): ?float
1569.     {
1570.         return $this->minBalanceAdmin;
1571.     }
1573.     public function setMinBalanceAdmin(?float $minBalanceAdmin): static
1574.     {
1575.         $this->minBalanceAdmin = $minBalanceAdmin;
1577.         return $this;
1578.     }
1580.     public function getMainCategoryId(): ?int
1581.     {
1582.         return $this->mainCategoryId;
1583.     }
1585.     public function setMainCategoryId(?int $mainCategoryId): static
1586.     {
1587.         $this->mainCategoryId = $mainCategoryId;
1589.         return $this;
1590.     }
1592.     public function isDiscontinued(): ?bool
1593.     {
1594.         return $this->discontinued;
1595.     }
1597.     public function setDiscontinued(?bool $discontinued): static
1598.     {
1599.         $this->discontinued = $discontinued;
1601.         return $this;
1602.     }
1604.     /**
1605.      * @return Collection<int, Documents>
1606.      */
1607.     public function getDocuments(): Collection
1608.     {
1609.         return $this->documents;
1610.     }
1612.     public function addDocument(Documents $document): static
1613.     {
1614.         if (!$this->documents->contains($document)) {
1615.             $this->documents->add($document);
1616.             $document->setProduct($this);
1617.         }
1619.         return $this;
1620.     }
1622.     public function removeDocument(Documents $document): static
1623.     {
1624.         if ($this->documents->removeElement($document)) {
1625.             // set the owning side to null (unless already changed)
1626.             if ($document->getProduct() === $this) {
1627.                 $document->setProduct(null);
1628.             }
1629.         }
1631.         return $this;
1632.     }
1633. }