src/Entity/Products.php line 104

Open in your IDE?
  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; 
  36. #[ORM\Entity(repositoryClass: ProductsRepository::class)]
  37. #[ApiResource(
  38.     operations: [
  39.         new Get(),
  40.         new Post(),
  41.         new Delete(),
  42.         new GetCollection(),
  43.         new Put(),
  44.         new Post(
  45.             name: 'batch', 
  46.             uriTemplate: '/products/batch', 
  47.             controller: BatchCreateProductAction::class
  48.         ),
  49.         new Get(
  50.             name: 'filter_product', 
  51.             uriTemplate: '/products/filter', 
  52.             controller: ProductController::class
  53.         )
  54.     ],
  55.     normalizationContext: ['groups' => ['product:read']],
  56.     denormalizationContext: ['groups' => ['product:write']],
  57.     order: ['id' => 'DESC'],
  58.     // paginationPartial: true,
  59.     paginationEnabled: true,
  60.     // filters: [ShowProductsFilter::class] 
  61. )]
  62. // #[Get]
  63. #[ORM\HasLifecycleCallbacks]
  65. #[ApiFilter(RangeFilter::class, properties: ['balance'])]
  67. // #[ApiFilter(CustomOrFilter::class,properties: [
  68. //     'name' => 'ipartial', 
  69. //     'barcode' => 'exact', 
  70. //     'article' => 'exact',
  71. //     'code1c' => 'exact',
  72. // ])]
  74. #[ApiFilter(
  75.     SearchFilter::class, 
  76.     properties: [
  77.         'id' => 'exact', 
  78.         'oldCode' => 'exact', 
  79.         // 'code1c' => 'exact', 
  80.         'top' => 'exact', 
  81.         'productToOrder' => 'exact', 
  82.         'name' => 'ipartial', 
  83.         // 'barcode' => 'exact', 
  84.         'category.id' => 'exact',
  85.         'attributeItems.id' => 'exact',
  86.         'show' => 'exact',
  87.         'article' => 'exact',
  88.         'prices.product' => 'exact',
  89.         'prices.agreement.virtual' => 'exact',
  90.         'prices.agreement.account.id' => 'exact',
  91.         'productBalanceInStorages.manager.id' => 'exact',
  92.         'orderProducts.order.account.id' => 'exact',
  93.         'orderProducts.order.account.user.id' => 'exact',
  94.     ],
  95. )]
  97. #[ApiFilter(OrderFilter::class, properties: ['price', 'name'], arguments: ['orderParameterName' => 'order'])]
  99. // #[ApiFilter(ShowProductsFilter::class)]
  101. // #[ApiFilter(ShowProductsFilter::class)]
  104. class Products
  105. {
  106.     #[ORM\Id]
  107.     #[ORM\GeneratedValue]
  108.     #[ORM\Column]
  109.     #[Groups(['product:read', 'product:write',  'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read', 'attributes:read',  'product_storage_balance:read', 'price:read'])]
  110.     private ?int $id = null;
  112.     #[ORM\Column(length: 255)]
  113.     #[Groups(['product:read', 'product:write',  'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read', 'attributes:read',  'product_storage_balance:read', 'price:read'])]
  114.     private ?string $name = null;
  116.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  117.     #[Groups(['product:read'])]
  118.     private ?\DateTimeInterface $date_entered;
  120.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  121.     #[Groups(['product:read'])]
  122.     private ?\DateTimeInterface $date_modified;
  124.     #[ORM\ManyToOne(inversedBy: 'products')]
  125.     #[Groups(['product:read'])]
  126.     #[MaxDepth(1)]
  127.     private ?User $modified_user = null;
  129.     #[ORM\ManyToOne(inversedBy: 'create_products')]
  130.     #[Groups(['product:read'])]
  131.     #[MaxDepth(1)]
  132.     private ?User $created_by;
  134.     #[Groups(['product:read', 'product:write'])]
  135.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  136.     private ?string $description = null;
  138.     #[ORM\Column(length: 20, nullable: true)]
  139.     #[Groups(['product:read', 'product:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'order_product:read', 'product_storage_balance:read'])]
  140.     private ?string $code1c = null;
  142.     #[ORM\Column(length: 100, nullable: true)]
  143.     #[Groups(['product:read', 'product:write',  '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', 'price:read'])]
  144.     private ?string $barcode = null;
  146.     #[ORM\Column(length: 100, nullable: true)]
  147.     #[Groups(['product:read', 'product:write'])]
  148.     private ?string $status = null;
  150.     #[ORM\Column(nullable: true)]
  151.     #[Groups(['product:read', 'product:write', 'order_product:read',  'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'attributes_items:read', 'attributes:read',  'product_storage_balance:read', 'price:read'])]
  152.     private ?float $price = null;
  154.     #[ORM\Column(nullable: true)]
  155.     #[Groups(['product:read', 'product:write', 'order_product:read'])]
  156.     private ?float $priceIncome = null;
  158.     #[ORM\Column(nullable: true)]
  159.     #[Groups(['product:read', 'product:write'])]
  160.     private ?float $mark_up = null;
  162.     #[ORM\Column]
  163.     #[Groups(['product:read', 'product:write'])]
  164.     private ?float $min_mark_up = 1;
  166.     #[ORM\Column(length: 100, nullable: true)]
  167.     #[Groups(['product:read', 'product:write'])]
  168.     private ?string $packing_type = null;
  170.     #[ORM\Column(nullable: true)]
  171.     #[Groups(['product:read', 'product:write'])]
  172.     private ?float $packing_type_count = null;
  174.     #[ORM\Column(nullable: true)]
  175.     #[Groups(['product:read', 'product:write', 'order_product:read'])]
  176.     private ?int $discounts = null;
  178.     #[ORM\Column]
  179.     #[Groups(['product:read', 'product:write'])]
  180.     private ?int $top = 0;
  182.     #[ORM\Column(nullable: true)]
  183.     #[Groups(['product:read', 'product:write'])]
  184.     private ?int $count_order = null;
  186.     #[ORM\Column(nullable: true)]
  187.     #[Groups(['product:read', 'product:write'])]
  188.     private ?int $productToOrder = null;
  190.     #[ORM\ManyToOne]
  191.     #[Groups(['product:read', 'product:write',  'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read'])]
  192.     #[ApiProperty(writable: true)]
  193.     #[MaxDepth(1)]
  194.     private ?MeasurmentUnit $measurement_unit = null;
  196.     #[Groups(['product:read', 'product:write'])]
  197.     #[MaxDepth(1)]
  198.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductInfo::class,)]
  199.     private ?Collection $productInfos = null;
  201.     #[MaxDepth(1)]
  202.     #[Groups(['product:read', 'product:write',  'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read'])]
  203.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: MediaObject::class)]
  204.     private Collection $media;
  206.     #[MaxDepth(2)]
  207.     #[Groups(['product:read', 'product:write'])]
  208.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: IncomingInvoiceProduct::class)]
  209.     private Collection $incomingInvoiceProducts;
  210.     
  211.     private ?SecurityInterface $security = null;
  213.     #[ORM\Column(length: 20, nullable: true)]
  214.     #[Groups(['product:read', 'product:write',  'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read'])]
  215.     private ?string $article = null;
  217.     #[ORM\Column(nullable: true)]
  218.     #[Groups(['product:read', 'product:write'])]
  219.     private ?float $nds = null;
  221.     #[ORM\Column(nullable: true)]
  222.     #[Groups(['product:read', 'product:write'])]
  223.     private ?bool $service = null;
  225.     #[ORM\Column(nullable: true)]
  226.     #[Groups(['product:read', 'product:write'])]
  227.     private ?bool $transport_service = null;
  229.     #[ORM\Column(nullable: true)]
  230.     #[Groups(['product:read', 'product:write'])]
  231.     private ?bool $exise = false;
  233.     #[ORM\Column(nullable: true)]
  234.     #[Groups(['product:read', 'product:write'])]
  235.     private ?bool $expiration_date = null;
  237.     #[ORM\Column(nullable: true)]
  238.     #[Groups(['product:read', 'product:write'])]
  239.     private ?float $unit_volume = null;
  241.     #[ORM\Column(nullable: true)]
  242.     #[Groups(['product:read', 'product:write'])]
  243.     private ?float $net_weight = null;
  245.     #[ORM\Column(nullable: true)]
  246.     #[Groups(['product:read', 'product:write'])]
  247.     private ?float $gross_weight = null;
  249.     #[ORM\Column(nullable: true)]
  250.     #[Groups(['product:read', 'product:write'])]
  251.     private ?bool $go_by_weight = null;
  253.     #[ORM\Column(nullable: true)]
  254.     #[Groups(['product:read', 'product:write'])]
  255.     private ?float $packaging = null;
  257.     #[ORM\ManyToOne(inversedBy: 'products')]
  258.     #[MaxDepth(2)]
  259.     #[Groups(['product:read', 'product:write'])]
  260.     private ?SiteProducts $site_product = null;
  262.     #[Groups(['product:read', 'product:write',  'attributes:read'])]
  263.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
  264.     #[MaxDepth(1)]
  265.     private Collection $category;
  267.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: MediaObject::class)]
  268.     private Collection $mediaObjects;
  270.     #[Groups(['product:read', 'product:write'])]
  271.     #[ORM\Column(length: 100, nullable: true)]
  272.     private ?string $oldCode = null;
  274.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: UserLikeList::class)]
  275.     private Collection $userLikeLists;
  277.     #[Groups(['product:read', 'product:write'])]
  278.     #[ORM\ManyToMany(targetEntity: AttributeItems::class, mappedBy: 'product')] 
  279.     private Collection $attributeItems;
  282.     #[Groups(['product:read', 'product:write',  'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read'])]
  283.     #[ORM\Column(nullable: true)]
  284.     private ?bool $show = null;
  286.     #[Groups(['product:read', 'product:write',  'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read'])]
  287.     #[ORM\ManyToOne(inversedBy: 'products')]
  288.     private ?Storage $storage = null;
  290.     #[MaxDepth(2)]
  291.     #[Groups(['product:read', 'product:write','order:read', 'order_product:read'])]
  292.     #[ORM\ManyToOne(inversedBy: 'products')]
  293.     private ?StorageElement $storageElement = null;
  295.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Prices::class)]
  296.     private Collection $prices;
  298.     #[Groups(['product:read', 'product:write', 'order_product:read', 'pre_order_product:read'])]
  299.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductBalanceInStorage::class)]
  300.     private Collection $productBalanceInStorages;
  302.     #[Groups(['product:read', 'product:write',  'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read', 'attributes:read',  ])]
  303.     #[ORM\Column(nullable: true)]
  304.     private ?float $balance = null;
  306.     #[ApiProperty(writable: true)]
  307.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderProduct::class)]
  308.     private Collection $orderProducts;
  310.     public function __construct() {
  311.         $this->productInfos = new ArrayCollection();
  312.         $this->media = new ArrayCollection();
  313.         $this->incomingInvoiceProducts = new ArrayCollection();
  314.         $this->category = new ArrayCollection();
  315.         $this->mediaObjects = new ArrayCollection();
  316.         $this->userLikeLists = new ArrayCollection();
  317.         $this->attributeItems = new ArrayCollection();
  318.         $this->prices = new ArrayCollection();
  319.         $this->productBalanceInStorages = new ArrayCollection();
  320.         $this->orderProducts = new ArrayCollection();
  322.     }
  324.     public function getId(): ?int
  325.     {
  326.         return $this->id;
  327.     }
  329.     public function setId(string $id): self
  330.     {
  331.         $this->id = $id;
  333.         return $this;
  334.     }
  336.     public function getName(): ?string
  337.     {
  338.         return $this->name;
  339.     }
  341.     public function setName(string $name): self
  342.     {
  343.         $this->name = $name;
  345.         return $this;
  346.     }
  348.     public function getDateEntered(): ?\DateTimeInterface
  349.     {
  350.         return $this->date_entered;
  351.     }
  353.     // public function setDateEntered(?\DateTimeInterface $date_entered): self
  354.     // {
  355.     //     $this->date_entered = $date_entered;
  357.     //     return $this;
  358.     // }
  360.     public function getDateModified(): ?\DateTimeInterface
  361.     {
  362.         return $this->date_modified;
  363.     }
  365.     // public function setDateModified(?\DateTimeInterface $date_modified): self
  366.     // {
  367.     //     $this->date_modified = $date_modified;
  369.     //     return $this;
  370.     // }
  372.     public function getModifiedUser(): ?User
  373.     {
  374.         return $this->modified_user;
  375.     }
  377.     // public function setModifiedUserId(?User $modified_user_id): self
  378.     // {
  379.     //     $this->modified_user_id = $modified_user_id;
  381.     //     return $this;
  382.     // }
  384.     public function getCreatedBy(): ?User
  385.     {
  386.         return $this->created_by;
  387.     }
  389.     public function setCreatedBy(?User $created_by): self
  390.     {
  391.         $this->created_by = $created_by;
  393.         return $this;
  394.     }
  396.     public function getDescription(): ?string
  397.     {
  398.         return $this->description;
  399.     }
  401.     public function setDescription(?string $description): self
  402.     {
  403.         $this->description = $description;
  405.         return $this;
  406.     }
  408.     public function getCode1c(): ?string
  409.     {
  410.         return $this->code1c;
  411.     }
  413.     public function setCode1c(?string $code1c): self
  414.     {
  415.         $this->code1c = $code1c;
  417.         return $this;
  418.     }
  420.     public function getBarcode(): ?string
  421.     {
  422.         return $this->barcode;
  423.     }
  425.     public function setBarcode(?string $barcode): self
  426.     {
  427.         $this->barcode = $barcode;
  429.         return $this;
  430.     }
  432.     public function getStatus(): ?string
  433.     {
  434.         return $this->status;
  435.     }
  437.     public function setStatus(?string $status): self
  438.     {
  439.         $this->status = $status;
  441.         return $this;
  442.     }
  444.     public function getPrice(): ?float
  445.     {
  446.         return $this->price;
  447.     }
  449.     public function setPrice(?float $price): self
  450.     {
  451.         $this->price = $price;
  453.         return $this;
  454.     }
  456.     public function getPriceIncome(): ?float
  457.     {
  458.         return $this->priceIncome;
  459.     }
  461.     public function setPriceIncome(?float $priceIncome): self
  462.     {
  463.         $this->priceIncome = $priceIncome;
  465.         return $this;
  466.     }
  468.     public function getMarkUp(): ?float
  469.     {
  470.         return $this->mark_up;
  471.     }
  473.     public function setMarkUp(?float $mark_up): self
  474.     {
  475.         $this->mark_up = $mark_up;
  477.         return $this;
  478.     }
  480.     public function getMinMarkUp(): ?float
  481.     {
  482.         return $this->min_mark_up;
  483.     }
  485.     public function setMinMarkUp(float $min_mark_up): self
  486.     {
  487.         $this->min_mark_up = $min_mark_up;
  489.         return $this;
  490.     }
  492.     public function getPackingType(): ?string
  493.     {
  494.         return $this->packing_type;
  495.     }
  497.     public function setPackingType(?string $packing_type): self
  498.     {
  499.         $this->packing_type = $packing_type;
  501.         return $this;
  502.     }
  504.     public function getPackingTypeCount(): ?float
  505.     {
  506.         return $this->packing_type_count;
  507.     }
  509.     public function setPackingTypeCount(?float $packing_type_count): self
  510.     {
  511.         $this->packing_type_count = $packing_type_count;
  513.         return $this;
  514.     }
  516.     public function getDiscounts(): ?int
  517.     {
  518.         return $this->discounts;
  519.     }
  521.     public function setDiscounts(?int $discounts): self
  522.     {
  523.         $this->discounts = $discounts;
  525.         return $this;
  526.     }
  528.     public function getTop(): ?int
  529.     {
  530.         return $this->top;
  531.     }
  533.     public function setTop(int $top): self
  534.     {
  535.         $this->top = $top;
  537.         return $this;
  538.     }
  540.     public function getCountOrder(): ?int
  541.     {
  542.         return $this->count_order;
  543.     }
  545.     public function setCountOrder(?int $count_order): self
  546.     {
  547.         $this->count_order = $count_order;
  549.         return $this;
  550.     }
  552.     public function getProductToOrder(): ?int
  553.     {
  554.         return $this->productToOrder;
  555.     }
  557.     public function setProductToOrder(?int $productToOrder): self
  558.     {
  559.         $this->productToOrder = $productToOrder;
  561.         return $this;
  562.     }
  564.     public function getMeasurementUnit(): ?MeasurmentUnit
  565.     {
  566.         return $this->measurement_unit;
  567.     }
  569.     public function setMeasurementUnit(?MeasurmentUnit $measurement_unit_id): self
  570.     {
  571.         $this->measurement_unit = $measurement_unit_id;
  573.         return $this;
  574.     }
  576.     /**
  577.      * @return Collection<int, ProductInfo>
  578.      */
  579.     public function getProductInfos(): Collection
  580.     {
  581.         return $this->productInfos;
  582.     }
  584.     public function addProductInfo(ProductInfo $productInfo): self
  585.     {
  586.         if (!$this->productInfos->contains($productInfo)) {
  587.             $this->productInfos->add($productInfo);
  588.             $productInfo->setProduct($this);
  589.         }
  591.         return $this;
  592.     }
  594.     public function removeProductInfo(ProductInfo $productInfo): self
  595.     {
  596.         if ($this->productInfos->removeElement($productInfo)) {
  597.             // set the owning side to null (unless already changed)
  598.             if ($productInfo->getProduct() === $this) {
  599.                 $productInfo->setProduct(null);
  600.             }
  601.         }
  603.         return $this;
  604.     }
  606.     /**
  607.      * @return Collection<int, MediaObject>
  608.      */
  609.     public function getMedia(): Collection
  610.     {
  611.         return $this->media;
  612.     }
  614.     public function addMedium(MediaObject $medium): self
  615.     {
  616.         if (!$this->media->contains($medium)) {
  617.             $this->media->add($medium);
  618.             $medium->setProduct($this);
  619.         }
  621.         return $this;
  622.     }
  624.     public function removeMedium(MediaObject $medium): self
  625.     {
  626.         if ($this->media->removeElement($medium)) {
  627.             // set the owning side to null (unless already changed)
  628.             if ($medium->getProduct() === $this) {
  629.                 $medium->setProduct(null);
  630.             }
  631.         }
  633.         return $this;
  634.     }
  636.     /**
  637.      * @return Collection<int, IncomingInvoiceProduct>
  638.      */
  639.     public function getIncomingInvoiceProducts(): Collection
  640.     {
  641.         return $this->incomingInvoiceProducts;
  642.     }
  644.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  645.     {
  646.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  647.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  648.             $incomingInvoiceProduct->setProduct($this);
  649.         }
  651.         return $this;
  652.     }
  654.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  655.     {
  656.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  657.             // set the owning side to null (unless already changed)
  658.             if ($incomingInvoiceProduct->getProduct() === $this) {
  659.                 $incomingInvoiceProduct->setProduct(null);
  660.             }
  661.         }
  663.         return $this;
  664.     }
  666.     #[ORM\PrePersist]
  667.     public function setCreatedAtValue(): void
  668.     {
  669.         $this->date_entered = new \DateTime();
  670.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', $this->getCurrentUserId() . "\n", FILE_APPEND);
  671.         $this->created_by = $this->getCurrentUserId();
  672.     }
  674.     // #[ORM\PrePersist]
  675.     #[ORM\PreUpdate]
  676.     public function setUpdatedAtValue(): void
  677.     {
  678.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', "222222\n", FILE_APPEND);
  679.         $this->date_modified = new \DateTime();
  680.         $this->modified_user = $this->getCurrentUserId();
  681.     }
  683.     public function getCurrentUserId(): ?User
  684.     {
  685.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', print_r($this->security, true)."\n", FILE_APPEND);
  686.         if (!$this->security) {
  687.             return null;
  688.         }
  690.         $token = $this->security->getToken();
  691.         if (!$token) {
  692.             return null;
  693.         }
  695.         $user = $token->getUser();
  696.         if (!$user instanceof User) {
  697.             return null;
  698.         }
  700.         return $user;
  701.     }
  703.     public function __sleep()
  704.     {
  705.         return [
  706.             'modified_user',
  707.             // 'created_by',
  708.             // 'date_entered',
  709.             'date_modified'
  710.         ];
  711.     }
  713.     public function __wakeup(): void
  714.     {
  715.         $this->security = null;
  716.     }
  718.     public function getArticle(): ?string
  719.     {
  720.         return $this->article;
  721.     }
  723.     public function setArticle(?string $article): self
  724.     {
  725.         $this->article = $article;
  727.         return $this;
  728.     }
  730.     public function getNds(): ?float
  731.     {
  732.         return $this->nds;
  733.     }
  735.     public function setNds(?float $nds): self
  736.     {
  737.         $this->nds = $nds;
  739.         return $this;
  740.     }
  742.     public function isService(): ?bool
  743.     {
  744.         return $this->service;
  745.     }
  747.     public function setService(?bool $service): self
  748.     {
  749.         $this->service = $service;
  751.         return $this;
  752.     }
  754.     public function isTransportService(): ?bool
  755.     {
  756.         return $this->transport_service;
  757.     }
  759.     public function setTransportService(?bool $transport_service): self
  760.     {
  761.         $this->transport_service = $transport_service;
  763.         return $this;
  764.     }
  766.     public function isExise(): ?bool
  767.     {
  768.         return $this->exise;
  769.     }
  771.     public function setExise(bool $exise): self
  772.     {
  773.         $this->exise = $exise;
  775.         return $this;
  776.     }
  778.     public function isExpirationDate(): ?bool
  779.     {
  780.         return $this->expiration_date;
  781.     }
  783.     public function setExpirationDate(?bool $expiration_date): self
  784.     {
  785.         $this->expiration_date = $expiration_date;
  787.         return $this;
  788.     }
  790.     public function getUnitVolume(): ?float
  791.     {
  792.         return $this->unit_volume;
  793.     }
  795.     public function setUnitVolume(?float $unit_volume): self
  796.     {
  797.         $this->unit_volume = $unit_volume;
  799.         return $this;
  800.     }
  802.     public function getNetWeight(): ?float
  803.     {
  804.         return $this->net_weight;
  805.     }
  807.     public function setNetWeight(?float $net_weight): self
  808.     {
  809.         $this->net_weight = $net_weight;
  811.         return $this;
  812.     }
  814.     public function getGrossWeight(): ?float
  815.     {
  816.         return $this->gross_weight;
  817.     }
  819.     public function setGrossWeight(?float $gross_weight): self
  820.     {
  821.         $this->gross_weight = $gross_weight;
  823.         return $this;
  824.     }
  826.     public function isGoByWeight(): ?bool
  827.     {
  828.         return $this->go_by_weight;
  829.     }
  831.     public function setGoByWeight(?bool $go_by_weight): self
  832.     {
  833.         $this->go_by_weight = $go_by_weight;
  835.         return $this;
  836.     }
  838.     public function getPackaging(): ?float
  839.     {
  840.         return $this->packaging;
  841.     }
  843.     public function setPackaging(?float $packaging): self
  844.     {
  845.         $this->packaging = $packaging;
  847.         return $this;
  848.     }
  850.     public function getSiteProduct(): ?SiteProducts
  851.     {
  852.         return $this->site_product;
  853.     }
  855.     public function setSiteProduct(?SiteProducts $site_product): self
  856.     {
  857.         $this->site_product = $site_product;
  859.         return $this;
  860.     }
  862.     /**
  863.      * @return Collection<int, Category>
  864.      */
  865.     public function getCategory(): Collection
  866.     {
  867.         return $this->category;
  868.     }
  870.     public function addCategory(Category $category): self
  871.     {
  872.         if (!$this->category->contains($category)) {
  873.             $this->category->add($category);
  874.         }
  876.         return $this;
  877.     }
  879.     public function removeCategory(Category $category): self
  880.     {
  881.         $this->category->removeElement($category);
  883.         return $this;
  884.     }
  886.     /**
  887.      * @return Collection<int, MediaObject>
  888.      */
  889.     public function getMediaObjects(): Collection
  890.     {
  891.         return $this->mediaObjects;
  892.     }
  894.     public function addMediaObject(MediaObject $mediaObject): self
  895.     {
  896.         if (!$this->mediaObjects->contains($mediaObject)) {
  897.             $this->mediaObjects->add($mediaObject);
  898.             $mediaObject->setProduct($this);
  899.         }
  901.         return $this;
  902.     }
  904.     public function removeMediaObject(MediaObject $mediaObject): self
  905.     {
  906.         if ($this->mediaObjects->removeElement($mediaObject)) {
  907.             // set the owning side to null (unless already changed)
  908.             if ($mediaObject->getProduct() === $this) {
  909.                 $mediaObject->setProduct(null);
  910.             }
  911.         }
  913.         return $this;
  914.     }
  916.     public function getOldCode(): ?string
  917.     {
  918.         return $this->oldCode;
  919.     }
  921.     public function setOldCode(string $oldCode): self
  922.     {
  923.         $this->oldCode = $oldCode;
  925.         return $this;
  926.     }
  928.     /**
  929.      * @return Collection<int, UserLikeList>
  930.      */
  931.     public function getUserLikeLists(): Collection
  932.     {
  933.         return $this->userLikeLists;
  934.     }
  936.     public function addUserLikeList(UserLikeList $userLikeList): self
  937.     {
  938.         if (!$this->userLikeLists->contains($userLikeList)) {
  939.             $this->userLikeLists->add($userLikeList);
  940.             $userLikeList->setз�product($this);
  941.         }
  943.         return $this;
  944.     }
  946.     public function removeUserLikeList(UserLikeList $userLikeList): self
  947.     {
  948.         if ($this->userLikeLists->removeElement($userLikeList)) {
  949.             // set the owning side to null (unless already changed)
  950.             if ($userLikeList->getз�product() === $this) {
  951.                 $userLikeList->setз�product(null);
  952.             }
  953.         }
  955.         return $this;
  956.     }
  958.     /**
  959.      * @return Collection<int, AttributeItems>
  960.      */
  961.     public function getAttributeItems(): Collection
  962.     {
  963.         return $this->attributeItems;
  964.     }
  966.     public function addAttributeItem(AttributeItems $attributeItem): self
  967.     {
  968.         if (!$this->attributeItems->contains($attributeItem)) {
  969.             $this->attributeItems->add($attributeItem);
  970.             $attributeItem->addProduct($this);
  971.         }
  973.         return $this;
  974.     }
  976.     public function removeAttributeItem(AttributeItems $attributeItem): self
  977.     {
  978.         if ($this->attributeItems->removeElement($attributeItem)) {
  979.             $attributeItem->removeProduct($this);
  980.         }
  982.         return $this;
  983.     }
  985.     public function isShow(): ?bool
  986.     {
  987.         return $this->show;
  988.     }
  990.     public function setShow(?bool $show): self
  991.     {
  992.         $this->show = $show;
  994.         return $this;
  995.     }
  997.     public function getStorage(): ?Storage
  998.     {
  999.         return $this->storage;
  1000.     }
  1002.     public function setStorage(?Storage $storage): self
  1003.     {
  1004.         $this->storage = $storage;
  1006.         return $this;
  1007.     }
  1009.     public function getStorageElement(): ?StorageElement
  1010.     {
  1011.         return $this->storageElement;
  1012.     }
  1014.     public function setStorageElement(?StorageElement $storageElement): self
  1015.     {
  1016.         $this->storageElement = $storageElement;
  1018.         return $this;
  1019.     }
  1020.     
  1021.     /**
  1022.      * @return Collection<int, Prices>
  1023.      */
  1024.     public function getPrices(): Collection
  1025.     {
  1026.         return $this->prices;
  1027.     }
  1029.     public function addPrice(Prices $price): static
  1030.     {
  1031.         if (!$this->prices->contains($price)) {
  1032.             $this->prices->add($price);
  1033.             $price->setAgreement($this);
  1034.         }
  1036.         return $this;
  1037.     }
  1039.     public function removePrice(Prices $price): static
  1040.     {
  1041.         if ($this->prices->removeElement($price)) {
  1042.             // set the owning side to null (unless already changed)
  1043.             if ($price->getAgreement() === $this) {
  1044.                 $price->setAgreement(null);
  1045.             }
  1046.         }
  1048.         return $this;
  1049.     }
  1051.     /**
  1052.      * @return Collection<int, ProductBalanceInStorage>
  1053.      */
  1054.     public function getProductBalanceInStorages(): Collection
  1055.     {
  1056.         return $this->productBalanceInStorages;
  1057.     }
  1059.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1060.     {
  1061.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  1062.             $this->productBalanceInStorages->add($productBalanceInStorage);
  1063.             $productBalanceInStorage->setProduct($this);
  1064.         }
  1066.         return $this;
  1067.     }
  1069.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1070.     {
  1071.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  1072.             // set the owning side to null (unless already changed)
  1073.             if ($productBalanceInStorage->getProduct() === $this) {
  1074.                 $productBalanceInStorage->setProduct(null);
  1075.             }
  1076.         }
  1078.         return $this;
  1079.     }
  1081.     public function getBalance(): ?float
  1082.     {
  1083.         return $this->balance;
  1084.     }
  1086.     public function setBalance(?float $balance): self
  1087.     {
  1088.         $this->balance = $balance;
  1090.         return $this;
  1091.     }
  1093.     /**
  1094.      * @return Collection<int, OrderProduct>
  1095.      */
  1096.     public function getOrderProducts(): Collection
  1097.     {
  1098.         return $this->orderProducts;
  1099.     }
  1101.     public function addOrderProduct(OrderProduct $orderProduct): self
  1102.     {
  1103.         if (!$this->orderProducts->contains($orderProduct)) {
  1104.             $this->orderProducts->add($orderProduct);
  1105.             $orderProduct->setOrder($this);
  1106.         }
  1108.         return $this;
  1109.     }
  1111.     public function removeOrderProduct(OrderProduct $orderProduct): self
  1112.     {
  1113.         if ($this->orderProducts->removeElement($orderProduct)) {
  1114.             // set the owning side to null (unless already changed)
  1115.             if ($orderProduct->getOrder() === $this) {
  1116.                 $orderProduct->setOrder(null);
  1117.             }
  1118.         }
  1120.         return $this;
  1121.     }
  1122. }