src/Entity/Products.php line 106

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; 
  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'],
  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.         // 'attributeItems.id' => 'exact',
  83.         'show' => 'exact',
  84.         'article' => 'exact',
  85.         'prices.product' => 'exact',
  86.         'prices.agreement.virtual' => 'exact',
  87.         'prices.agreement.account.id' => 'exact',
  88.         'productBalanceInStorages.manager.id' => 'exact',
  89.         'orderProducts.order.account.id' => 'exact',
  90.         'orderProducts.order.account.user.id' => 'exact',
  91.         'categoryCnt' => 'exact',
  92.         'deleted' => 'exact', 
  93.     ],
  94. )]
  96. #[ApiFilter(AttributeFilter::class)]  
  98. #[ApiFilter(OrderFilter::class, properties: ['price', 'name'], arguments: ['orderParameterName' => 'order'])]
  100. #[Index(name: "show", columns: ["show", "deleted"])]
  102. #[ApiFilter(GroupFilter::class, arguments: ['parameterName' => 'g', 'overrideDefaultGroups' => true])]
  104. #[ApiFilter(ExistsFilter::class, properties: ['attributeItems'])]
  106. class Products
  107. {
  108.     #[ORM\Id]
  109.     #[ORM\GeneratedValue]
  110.     #[ORM\Column]
  111.     #[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'])]
  112.     private ?int $id = null;
  114.     #[ORM\Column(length: 255)]
  115.     #[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'])]
  116.     private ?string $name = null;
  118.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  119.     #[Groups(['product:admin'])]
  120.     private ?\DateTimeInterface $date_entered;
  122.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  123.     #[Groups(['product:admin'])]
  124.     private ?\DateTimeInterface $date_modified;
  126.     #[ORM\ManyToOne(inversedBy: 'products')]
  127.     #[Groups(['product:modified_user'])]
  128.     #[MaxDepth(1)]
  129.     private ?User $modified_user = null;
  131.     #[ORM\ManyToOne(inversedBy: 'create_products')]
  132.     #[Groups(['product:created_by'])]
  133.     #[MaxDepth(1)]
  134.     private ?User $created_by;
  136.     #[Groups(['product:read', 'product:write', 'site_product:read'])]
  137.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  138.     private ?string $description = null;
  140.     #[ORM\Column(length: 20, nullable: true)]
  141.     #[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'])]
  142.     private ?string $code1c = null;
  144.     #[ORM\Column(length: 100, nullable: true)]
  145.     #[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'])]
  146.     private ?string $barcode = null;
  148.     #[ORM\Column(length: 100, nullable: true)]
  149.     #[Groups(['product:read', 'product:write'])]
  150.     private ?string $status = null;
  152.     #[ORM\Column(nullable: true)]
  153.     #[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'])]
  154.     private ?float $price = null;
  156.     #[ORM\Column(nullable: true)]
  157.     #[Groups([ 'product:admin', 'product:write', 'order_product:read', 'product_releted:read'])]
  158.     private ?float $priceIncome = null;
  160.     #[ORM\Column(nullable: true)]
  161.     #[Groups(['product:admin', 'product:write'])]
  162.     private ?float $mark_up = null;
  164.     #[ORM\Column]
  165.     #[Groups(['product:admin', 'product:write'])]
  166.     private ?float $min_mark_up = 1;
  168.     #[ORM\Column(length: 100, nullable: true)]
  169.     #[Groups(['product:write'])]
  170.     private ?string $packing_type = null;
  172.     #[ORM\Column(nullable: true)]
  173.     #[Groups(['product:write'])]
  174.     private ?float $packing_type_count = null;
  176.     #[ORM\Column(nullable: true)]
  177.     #[Groups(['product:read', 'product:write', 'order_product:read', 'product_releted:read'])]
  178.     private ?int $discounts = null;
  180.     #[ORM\Column(nullable: true)]
  181.     #[Groups(['product:admin', 'product:write'])]
  182.     private ?int $count_order = null;
  184.     #[ORM\Column(nullable: true)]
  185.     #[Groups(['product:read', 'product:write'])]
  186.     private ?int $productToOrder = null;
  188.     #[ORM\ManyToOne]
  189.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read'])]
  190.     #[ApiProperty(writable: true)]
  191.     #[MaxDepth(1)]
  192.     private ?MeasurmentUnit $measurement_unit = null;
  194.     #[Groups(['product:productInfos', 'product:write', 'site_product:read'])]
  195.     #[MaxDepth(1)]
  196.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductInfo::class,)]
  197.     private ?Collection $productInfos = null;
  199.     #[MaxDepth(1)]
  200.     #[Groups(['product:media', 'product:write', 'cat:read', 'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  201.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: MediaObject::class)]
  202.     private Collection $media;
  204.     #[MaxDepth(2)]
  205.     #[Groups(['product:incomingInvoiceProducts', 'product:write'])]
  206.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: IncomingInvoiceProduct::class)]
  207.     private Collection $incomingInvoiceProducts;
  208.     
  209.     private ?SecurityInterface $security = null;
  211.     #[ORM\Column(length: 20, nullable: true)]
  212.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  213.     private ?string $article = null;
  215.     #[ORM\Column(nullable: true)]
  216.     #[Groups(['product:admin', 'product:write'])]
  217.     private ?float $nds = null;
  219.     #[ORM\Column(nullable: true)]
  220.     #[Groups(['product:admin', 'product:write'])]
  221.     private ?bool $service = null;
  223.     #[ORM\Column(nullable: true)]
  224.     #[Groups(['product:admin', 'product:write'])]
  225.     private ?bool $transport_service = null;
  227.     #[ORM\Column(nullable: true)]
  228.     #[Groups(['product:read', 'product:write'])]
  229.     private ?bool $exise = false;
  231.     #[ORM\Column(nullable: true)]
  232.     #[Groups(['product:read', 'product:write'])]
  233.     private ?bool $expiration_date = null;
  235.     #[ORM\Column(nullable: true)]
  236.     #[Groups(['product:read', 'product:write'])]
  237.     private ?float $unit_volume = null;
  239.     #[ORM\Column(nullable: true)]
  240.     #[Groups(['product:read', 'product:write'])]
  241.     private ?float $net_weight = null;
  243.     #[ORM\Column(nullable: true)]
  244.     #[Groups(['product:read', 'product:write'])]
  245.     private ?float $gross_weight = null;
  247.     #[ORM\Column(nullable: true)]
  248.     #[Groups(['product:read', 'product:write'])]
  249.     private ?bool $go_by_weight = null;
  251.     #[ORM\Column(nullable: true)]
  252.     #[Groups(['product:read', 'product:write'])]
  253.     private ?float $packaging = null;
  255.     #[ORM\ManyToOne(inversedBy: 'products')]
  256.     #[MaxDepth(1)]
  257.     #[Groups(['product:siteProduct', 'product:write'])]
  258.     private ?SiteProducts $siteProduct = null;
  260.     #[Groups([ 'product:category', 'product:write',  'attributes:read'])]
  261.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
  262.     #[MaxDepth(1)]
  263.     private Collection $category;
  264.     
  265.     #[Groups(['product:admin', 'product:write'])]
  266.     #[ORM\Column(length: 100, nullable: true)]
  267.     private ?string $oldCode = null;
  269.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: UserLikeList::class)]
  270.     private Collection $userLikeLists;
  272.     #[Groups(['product:attributeItems', 'product:write', 'site_product:read'])]
  273.     #[ORM\ManyToMany(targetEntity: AttributeItems::class, mappedBy: 'product')] 
  274.     private Collection $attributeItems;
  277.     #[Groups([ 'product:admin', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  278.     #[ORM\Column(nullable: true)]
  279.     private ?bool $show = null;
  281.     #[Groups(['product:storage', 'product:write', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  282.     #[ORM\ManyToOne(inversedBy: 'products')]
  283.     private ?Storage $storage = null;
  285.     #[MaxDepth(2)]
  286.     #[Groups(['product:storageElement', 'product:write','order:read', 'order_product:read'])]
  287.     #[ORM\ManyToOne(inversedBy: 'products')]
  288.     private ?StorageElement $storageElement = null;
  290.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Prices::class)]
  291.     private Collection $prices;
  293.     #[Groups(['product:productBalanceInStorages', 'product:write'])]
  294.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductBalanceInStorage::class)]
  295.     private Collection $productBalanceInStorages;
  297.     #[Groups(['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','site_product:read'])]
  298.     #[ORM\Column(nullable: true)]
  299.     private ?float $balance = null;
  301.     #[ApiProperty(writable: true)]
  302.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderProduct::class)]
  303.     private Collection $orderProducts;
  305.     #[Groups(['product:language', 'product:write'])]
  306.     #[ORM\ManyToOne(inversedBy: 'products')]
  307.     private ?Languages $language = null;
  309.     #[Groups(['product:language', 'product:write'])]
  310.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'products')]
  311.     private ?self $translations = null;
  313.     #[ORM\OneToMany(mappedBy: 'translations', targetEntity: self::class)]
  314.     private Collection $products;
  316.     #[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'])]
  317.     #[ORM\ManyToOne(inversedBy: 'MainProducts')]
  318.     private ?MediaObject $mainMedia = null;
  320.     #[Groups(['product:admin', 'product:write'])]
  321.     #[ORM\Column(nullable: true, options: ["default" => false])]
  322.     private ?bool $deleted = false;
  324.     #[Groups(['product:admin', 'product:write'])]
  325.     #[ORM\Column(nullable: true,  options: ["default" => 0])]
  326.     private ?int $categoryCnt = 0;
  328.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  329.     #[ORM\Column(nullable: true)]
  330.     private ?array $priceCategory = null;
  332.     #[Groups(['product:comments', 'product:write'])]
  333.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Comments::class)]
  334.     private Collection $comments;
  336.     #[Groups(['product:read', 'product:write'])]
  337.     #[ORM\Column(nullable: true)]
  338.     private ?bool $isSalle = null;
  340.     #[Groups(['product:read', 'product:write'])]
  341.     #[ORM\Column(nullable: true)]
  342.     private ?bool $isNew = null;
  344.     #[Groups(['product:read', 'product:write'])]
  345.     #[ORM\Column(nullable: true)]
  346.     private ?bool $isTop = null;
  348.     #[Groups(['product:hover', 'product:write'])]
  349.     #[ORM\ManyToOne(inversedBy: 'productsHover')]
  350.     private ?MediaObject $mainMediaHover = null;
  352.     #[Groups(['productsReleteds:read', 'product:write'])]
  353.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductsReleted::class)]
  354.     private Collection $productsReleteds;
  356.     #[ORM\OneToMany(mappedBy: 'relatedProduct', targetEntity: ProductsReleted::class)]
  357.     private Collection $parentProductRelateds;
  359.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
  360.     #[ORM\Column(nullable: true)]
  361.     private ?float $oldPrice = null;
  363.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
  364.     #[ORM\Column(nullable: true)]
  365.     private ?int $discountPercent = null;
  367.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  368.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  369.     private ?\DateTimeInterface $dateLastPriceIncome = null;
  371.     public function __construct() {
  372.         $this->productInfos = new ArrayCollection();
  373.         $this->media = new ArrayCollection();
  374.         $this->incomingInvoiceProducts = new ArrayCollection();
  375.         $this->category = new ArrayCollection();
  376.         // $this->mediaObjects = new ArrayCollection();
  377.         $this->userLikeLists = new ArrayCollection();
  378.         $this->attributeItems = new ArrayCollection();
  379.         $this->prices = new ArrayCollection();
  380.         $this->productBalanceInStorages = new ArrayCollection();
  381.         $this->orderProducts = new ArrayCollection();
  382.         $this->products = new ArrayCollection();
  383.         $this->comments = new ArrayCollection();
  384.         $this->productsReleteds = new ArrayCollection();
  385.         $this->parentProductRelateds = new ArrayCollection();
  387.     }
  389.     public function getId(): ?int
  390.     {
  391.         return $this->id;
  392.     }
  394.     public function setId(string $id): self
  395.     {
  396.         $this->id = $id;
  398.         return $this;
  399.     }
  401.     public function getName(): ?string
  402.     {
  403.         return $this->name;
  404.     }
  406.     public function setName(string $name): self
  407.     {
  408.         $this->name = $name;
  410.         return $this;
  411.     }
  413.     public function getDateEntered(): ?\DateTimeInterface
  414.     {
  415.         return $this->date_entered;
  416.     }
  418.     // public function setDateEntered(?\DateTimeInterface $date_entered): self
  419.     // {
  420.     //     $this->date_entered = $date_entered;
  422.     //     return $this;
  423.     // }
  425.     public function getDateModified(): ?\DateTimeInterface
  426.     {
  427.         return $this->date_modified;
  428.     }
  430.     // public function setDateModified(?\DateTimeInterface $date_modified): self
  431.     // {
  432.     //     $this->date_modified = $date_modified;
  434.     //     return $this;
  435.     // }
  437.     public function getModifiedUser(): ?User
  438.     {
  439.         return $this->modified_user;
  440.     }
  442.     // public function setModifiedUserId(?User $modified_user_id): self
  443.     // {
  444.     //     $this->modified_user_id = $modified_user_id;
  446.     //     return $this;
  447.     // }
  449.     public function getCreatedBy(): ?User
  450.     {
  451.         return $this->created_by;
  452.     }
  454.     public function setCreatedBy(?User $created_by): self
  455.     {
  456.         $this->created_by = $created_by;
  458.         return $this;
  459.     }
  461.     public function getDescription(): ?string
  462.     {
  463.         return $this->description;
  464.     }
  466.     public function setDescription(?string $description): self
  467.     {
  468.         $this->description = $description;
  470.         return $this;
  471.     }
  473.     public function getCode1c(): ?string
  474.     {
  475.         return $this->code1c;
  476.     }
  478.     public function setCode1c(?string $code1c): self
  479.     {
  480.         $this->code1c = $code1c;
  482.         return $this;
  483.     }
  485.     public function getBarcode(): ?string
  486.     {
  487.         return $this->barcode;
  488.     }
  490.     public function setBarcode(?string $barcode): self
  491.     {
  492.         $this->barcode = $barcode;
  494.         return $this;
  495.     }
  497.     public function getStatus(): ?string
  498.     {
  499.         return $this->status;
  500.     }
  502.     public function setStatus(?string $status): self
  503.     {
  504.         $this->status = $status;
  506.         return $this;
  507.     }
  509.     public function getPrice(): ?float
  510.     {
  511.         return $this->price;
  512.     }
  514.     public function setPrice(?float $price): self
  515.     {
  516.         $this->price = $price;
  518.         return $this;
  519.     }
  521.     public function getPriceIncome(): ?float
  522.     {
  523.         return $this->priceIncome;
  524.     }
  526.     public function setPriceIncome(?float $priceIncome): self
  527.     {
  528.         $this->priceIncome = $priceIncome;
  530.         return $this;
  531.     }
  533.     public function getMarkUp(): ?float
  534.     {
  535.         return $this->mark_up;
  536.     }
  538.     public function setMarkUp(?float $mark_up): self
  539.     {
  540.         $this->mark_up = $mark_up;
  542.         return $this;
  543.     }
  545.     public function getMinMarkUp(): ?float
  546.     {
  547.         return $this->min_mark_up;
  548.     }
  550.     public function setMinMarkUp(float $min_mark_up): self
  551.     {
  552.         $this->min_mark_up = $min_mark_up;
  554.         return $this;
  555.     }
  557.     public function getPackingType(): ?string
  558.     {
  559.         return $this->packing_type;
  560.     }
  562.     public function setPackingType(?string $packing_type): self
  563.     {
  564.         $this->packing_type = $packing_type;
  566.         return $this;
  567.     }
  569.     public function getPackingTypeCount(): ?float
  570.     {
  571.         return $this->packing_type_count;
  572.     }
  574.     public function setPackingTypeCount(?float $packing_type_count): self
  575.     {
  576.         $this->packing_type_count = $packing_type_count;
  578.         return $this;
  579.     }
  581.     public function getDiscounts(): ?int
  582.     {
  583.         return $this->discounts;
  584.     }
  586.     public function setDiscounts(?int $discounts): self
  587.     {
  588.         $this->discounts = $discounts;
  590.         return $this;
  591.     }
  593.     public function getCountOrder(): ?int
  594.     {
  595.         return $this->count_order;
  596.     }
  598.     public function setCountOrder(?int $count_order): self
  599.     {
  600.         $this->count_order = $count_order;
  602.         return $this;
  603.     }
  605.     public function getProductToOrder(): ?int
  606.     {
  607.         return $this->productToOrder;
  608.     }
  610.     public function setProductToOrder(?int $productToOrder): self
  611.     {
  612.         $this->productToOrder = $productToOrder;
  614.         return $this;
  615.     }
  617.     public function getMeasurementUnit(): ?MeasurmentUnit
  618.     {
  619.         return $this->measurement_unit;
  620.     }
  622.     public function setMeasurementUnit(?MeasurmentUnit $measurement_unit_id): self
  623.     {
  624.         $this->measurement_unit = $measurement_unit_id;
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, ProductInfo>
  631.      */
  632.     public function getProductInfos(): Collection
  633.     {
  634.         return $this->productInfos;
  635.     }
  637.     public function addProductInfo(ProductInfo $productInfo): self
  638.     {
  639.         if (!$this->productInfos->contains($productInfo)) {
  640.             $this->productInfos->add($productInfo);
  641.             $productInfo->setProduct($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeProductInfo(ProductInfo $productInfo): self
  648.     {
  649.         if ($this->productInfos->removeElement($productInfo)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($productInfo->getProduct() === $this) {
  652.                 $productInfo->setProduct(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  659.     /**
  660.      * @return Collection<int, MediaObject>
  661.      */
  662.     public function getMedia(): Collection
  663.     {
  664.         return $this->media;
  665.     }
  667.     public function addMedium(MediaObject $medium): self
  668.     {
  669.         if (!$this->media->contains($medium)) {
  670.             $this->media->add($medium);
  671.             $medium->setProduct($this);
  672.         }
  674.         return $this;
  675.     }
  677.     public function removeMedium(MediaObject $medium): self
  678.     {
  679.         if ($this->media->removeElement($medium)) {
  680.             // set the owning side to null (unless already changed)
  681.             if ($medium->getProduct() === $this) {
  682.                 $medium->setProduct(null);
  683.             }
  684.         }
  686.         return $this;
  687.     }
  689.     /**
  690.      * @return Collection<int, IncomingInvoiceProduct>
  691.      */
  692.     public function getIncomingInvoiceProducts(): Collection
  693.     {
  694.         return $this->incomingInvoiceProducts;
  695.     }
  697.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  698.     {
  699.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  700.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  701.             $incomingInvoiceProduct->setProduct($this);
  702.         }
  704.         return $this;
  705.     }
  707.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  708.     {
  709.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  710.             // set the owning side to null (unless already changed)
  711.             if ($incomingInvoiceProduct->getProduct() === $this) {
  712.                 $incomingInvoiceProduct->setProduct(null);
  713.             }
  714.         }
  716.         return $this;
  717.     }
  719.     #[ORM\PrePersist]
  720.     public function setCreatedAtValue(): void
  721.     {
  722.         $this->date_entered = new \DateTime();
  723.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', $this->getCurrentUserId() . "\n", FILE_APPEND);
  724.         $this->created_by = $this->getCurrentUserId();
  725.     }
  727.     // #[ORM\PrePersist]
  728.     #[ORM\PreUpdate]
  729.     public function setUpdatedAtValue(): void
  730.     {
  731.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', "222222\n", FILE_APPEND);
  732.         $this->date_modified = new \DateTime();
  733.         $this->modified_user = $this->getCurrentUserId();
  734.     }
  736.     public function getCurrentUserId(): ?User
  737.     {
  738.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', print_r($this->security, true)."\n", FILE_APPEND);
  739.         if (!$this->security) {
  740.             return null;
  741.         }
  743.         $token = $this->security->getToken();
  744.         if (!$token) {
  745.             return null;
  746.         }
  748.         $user = $token->getUser();
  749.         if (!$user instanceof User) {
  750.             return null;
  751.         }
  753.         return $user;
  754.     }
  756.     public function __sleep()
  757.     {
  758.         return [
  759.             'modified_user',
  760.             // 'created_by',
  761.             // 'date_entered',
  762.             'date_modified'
  763.         ];
  764.     }
  766.     public function __wakeup(): void
  767.     {
  768.         $this->security = null;
  769.     }
  771.     public function getArticle(): ?string
  772.     {
  773.         return $this->article;
  774.     }
  776.     public function setArticle(?string $article): self
  777.     {
  778.         $this->article = $article;
  780.         return $this;
  781.     }
  783.     public function getNds(): ?float
  784.     {
  785.         return $this->nds;
  786.     }
  788.     public function setNds(?float $nds): self
  789.     {
  790.         $this->nds = $nds;
  792.         return $this;
  793.     }
  795.     public function isService(): ?bool
  796.     {
  797.         return $this->service;
  798.     }
  800.     public function setService(?bool $service): self
  801.     {
  802.         $this->service = $service;
  804.         return $this;
  805.     }
  807.     public function isTransportService(): ?bool
  808.     {
  809.         return $this->transport_service;
  810.     }
  812.     public function setTransportService(?bool $transport_service): self
  813.     {
  814.         $this->transport_service = $transport_service;
  816.         return $this;
  817.     }
  819.     public function isExise(): ?bool
  820.     {
  821.         return $this->exise;
  822.     }
  824.     public function setExise(bool $exise): self
  825.     {
  826.         $this->exise = $exise;
  828.         return $this;
  829.     }
  831.     public function isExpirationDate(): ?bool
  832.     {
  833.         return $this->expiration_date;
  834.     }
  836.     public function setExpirationDate(?bool $expiration_date): self
  837.     {
  838.         $this->expiration_date = $expiration_date;
  840.         return $this;
  841.     }
  843.     public function getUnitVolume(): ?float
  844.     {
  845.         return $this->unit_volume;
  846.     }
  848.     public function setUnitVolume(?float $unit_volume): self
  849.     {
  850.         $this->unit_volume = $unit_volume;
  852.         return $this;
  853.     }
  855.     public function getNetWeight(): ?float
  856.     {
  857.         return $this->net_weight;
  858.     }
  860.     public function setNetWeight(?float $net_weight): self
  861.     {
  862.         $this->net_weight = $net_weight;
  864.         return $this;
  865.     }
  867.     public function getGrossWeight(): ?float
  868.     {
  869.         return $this->gross_weight;
  870.     }
  872.     public function setGrossWeight(?float $gross_weight): self
  873.     {
  874.         $this->gross_weight = $gross_weight;
  876.         return $this;
  877.     }
  879.     public function isGoByWeight(): ?bool
  880.     {
  881.         return $this->go_by_weight;
  882.     }
  884.     public function setGoByWeight(?bool $go_by_weight): self
  885.     {
  886.         $this->go_by_weight = $go_by_weight;
  888.         return $this;
  889.     }
  891.     public function getPackaging(): ?float
  892.     {
  893.         return $this->packaging;
  894.     }
  896.     public function setPackaging(?float $packaging): self
  897.     {
  898.         $this->packaging = $packaging;
  900.         return $this;
  901.     }
  903.     public function getSiteProduct(): ?SiteProducts
  904.     {
  905.         return $this->siteProduct;
  906.     }
  908.     public function setSiteProduct(?SiteProducts $siteProduct): self
  909.     {
  910.         $this->siteProduct = $siteProduct;
  912.         return $this;
  913.     }
  915.     /**
  916.      * @return Collection<int, Category>
  917.      */
  918.     public function getCategory(): Collection
  919.     {
  920.         return $this->category;
  921.     }
  923.     public function addCategory(Category $category): self
  924.     {
  925.         if (!$this->category->contains($category)) {
  926.             $this->category->add($category);
  927.         }
  929.         return $this;
  930.     }
  932.     public function removeCategory(Category $category): self
  933.     {
  934.         $this->category->removeElement($category);
  936.         return $this;
  937.     }
  939.     /**
  940.      * @return Collection<int, MediaObject>
  941.      */
  942.     public function getMediaObjects(): Collection
  943.     {
  944.         return $this->mediaObjects;
  945.     }
  947.     public function addMediaObject(MediaObject $mediaObject): self
  948.     {
  949.         if (!$this->mediaObjects->contains($mediaObject)) {
  950.             $this->mediaObjects->add($mediaObject);
  951.             $mediaObject->setProduct($this);
  952.         }
  954.         return $this;
  955.     }
  957.     public function removeMediaObject(MediaObject $mediaObject): self
  958.     {
  959.         if ($this->mediaObjects->removeElement($mediaObject)) {
  960.             // set the owning side to null (unless already changed)
  961.             if ($mediaObject->getProduct() === $this) {
  962.                 $mediaObject->setProduct(null);
  963.             }
  964.         }
  966.         return $this;
  967.     }
  969.     public function getOldCode(): ?string
  970.     {
  971.         return $this->oldCode;
  972.     }
  974.     public function setOldCode(string $oldCode): self
  975.     {
  976.         $this->oldCode = $oldCode;
  978.         return $this;
  979.     }
  981.     /**
  982.      * @return Collection<int, UserLikeList>
  983.      */
  984.     public function getUserLikeLists(): Collection
  985.     {
  986.         return $this->userLikeLists;
  987.     }
  989.     public function addUserLikeList(UserLikeList $userLikeList): self
  990.     {
  991.         if (!$this->userLikeLists->contains($userLikeList)) {
  992.             $this->userLikeLists->add($userLikeList);
  993.             $userLikeList->setз�product($this);
  994.         }
  996.         return $this;
  997.     }
  999.     public function removeUserLikeList(UserLikeList $userLikeList): self
  1000.     {
  1001.         if ($this->userLikeLists->removeElement($userLikeList)) {
  1002.             // set the owning side to null (unless already changed)
  1003.             if ($userLikeList->getз�product() === $this) {
  1004.                 $userLikeList->setз�product(null);
  1005.             }
  1006.         }
  1008.         return $this;
  1009.     }
  1011.     /**
  1012.      * @return Collection<int, AttributeItems>
  1013.      */
  1014.     public function getAttributeItems(): Collection
  1015.     {
  1016.         return $this->attributeItems;
  1017.     }
  1019.     public function addAttributeItem(AttributeItems $attributeItem): self
  1020.     {
  1021.         if (!$this->attributeItems->contains($attributeItem)) {
  1022.             $this->attributeItems->add($attributeItem);
  1023.             $attributeItem->addProduct($this);
  1024.         }
  1026.         return $this;
  1027.     }
  1029.     public function removeAttributeItem(AttributeItems $attributeItem): self
  1030.     {
  1031.         if ($this->attributeItems->removeElement($attributeItem)) {
  1032.             $attributeItem->removeProduct($this);
  1033.         }
  1035.         return $this;
  1036.     }
  1038.     public function isShow(): ?bool
  1039.     {
  1040.         return $this->show;
  1041.     }
  1043.     public function setShow(?bool $show): self
  1044.     {
  1045.         $this->show = $show;
  1047.         return $this;
  1048.     }
  1050.     public function getStorage(): ?Storage
  1051.     {
  1052.         return $this->storage;
  1053.     }
  1055.     public function setStorage(?Storage $storage): self
  1056.     {
  1057.         $this->storage = $storage;
  1059.         return $this;
  1060.     }
  1062.     public function getStorageElement(): ?StorageElement
  1063.     {
  1064.         return $this->storageElement;
  1065.     }
  1067.     public function setStorageElement(?StorageElement $storageElement): self
  1068.     {
  1069.         $this->storageElement = $storageElement;
  1071.         return $this;
  1072.     }
  1073.     
  1074.     /**
  1075.      * @return Collection<int, Prices>
  1076.      */
  1077.     public function getPrices(): Collection
  1078.     {
  1079.         return $this->prices;
  1080.     }
  1082.     public function addPrice(Prices $price): static
  1083.     {
  1084.         if (!$this->prices->contains($price)) {
  1085.             $this->prices->add($price);
  1086.             $price->setAgreement($this);
  1087.         }
  1089.         return $this;
  1090.     }
  1092.     public function removePrice(Prices $price): static
  1093.     {
  1094.         if ($this->prices->removeElement($price)) {
  1095.             // set the owning side to null (unless already changed)
  1096.             if ($price->getAgreement() === $this) {
  1097.                 $price->setAgreement(null);
  1098.             }
  1099.         }
  1101.         return $this;
  1102.     }
  1104.     /**
  1105.      * @return Collection<int, ProductBalanceInStorage>
  1106.      */
  1107.     public function getProductBalanceInStorages(): Collection
  1108.     {
  1109.         return $this->productBalanceInStorages;
  1110.     }
  1112.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1113.     {
  1114.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  1115.             $this->productBalanceInStorages->add($productBalanceInStorage);
  1116.             $productBalanceInStorage->setProduct($this);
  1117.         }
  1119.         return $this;
  1120.     }
  1122.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1123.     {
  1124.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  1125.             // set the owning side to null (unless already changed)
  1126.             if ($productBalanceInStorage->getProduct() === $this) {
  1127.                 $productBalanceInStorage->setProduct(null);
  1128.             }
  1129.         }
  1131.         return $this;
  1132.     }
  1134.     public function getBalance(): ?float
  1135.     {
  1136.         return $this->balance;
  1137.     }
  1139.     public function setBalance(?float $balance): self
  1140.     {
  1141.         $this->balance = $balance;
  1143.         return $this;
  1144.     }
  1146.     /**
  1147.      * @return Collection<int, OrderProduct>
  1148.      */
  1149.     public function getOrderProducts(): Collection
  1150.     {
  1151.         return $this->orderProducts;
  1152.     }
  1154.     public function addOrderProduct(OrderProduct $orderProduct): self
  1155.     {
  1156.         if (!$this->orderProducts->contains($orderProduct)) {
  1157.             $this->orderProducts->add($orderProduct);
  1158.             $orderProduct->setOrder($this);
  1159.         }
  1161.         return $this;
  1162.     }
  1164.     public function removeOrderProduct(OrderProduct $orderProduct): self
  1165.     {
  1166.         if ($this->orderProducts->removeElement($orderProduct)) {
  1167.             // set the owning side to null (unless already changed)
  1168.             if ($orderProduct->getOrder() === $this) {
  1169.                 $orderProduct->setOrder(null);
  1170.             }
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     public function getLanguage(): ?Languages
  1177.     {
  1178.         return $this->language;
  1179.     }
  1181.     public function setLanguage(?Languages $language): self
  1182.     {
  1183.         $this->language = $language;
  1185.         return $this;
  1186.     }
  1188.     public function getTranslations(): ?self
  1189.     {
  1190.         return $this->translations;
  1191.     }
  1193.     public function setTranslations(?self $translations): self
  1194.     {
  1195.         $this->translations = $translations;
  1197.         return $this;
  1198.     }
  1200.     /**
  1201.      * @return Collection<int, self>
  1202.      */
  1203.     public function getProducts(): Collection
  1204.     {
  1205.         return $this->products;
  1206.     }
  1208.     public function addProduct(self $product): self
  1209.     {
  1210.         if (!$this->products->contains($product)) {
  1211.             $this->products->add($product);
  1212.             $product->setTranslations($this);
  1213.         }
  1215.         return $this;
  1216.     }
  1218.     public function removeProduct(self $product): self
  1219.     {
  1220.         if ($this->products->removeElement($product)) {
  1221.             // set the owning side to null (unless already changed)
  1222.             if ($product->getTranslations() === $this) {
  1223.                 $product->setTranslations(null);
  1224.             }
  1225.         }
  1227.         return $this;
  1228.     }
  1230.     public function getMainMedia(): ?MediaObject
  1231.     {
  1232.         return $this->mainMedia;
  1233.     }
  1235.     public function setMainMedia(?MediaObject $mainMedia): self
  1236.     {
  1237.         $this->mainMedia = $mainMedia;
  1239.         return $this;
  1240.     }
  1242.     public function isDeleted(): ?bool
  1243.     {
  1244.         return $this->deleted;
  1245.     }
  1247.     public function setDeleted(?bool $deleted): static
  1248.     {
  1249.         $this->deleted = $deleted;
  1251.         return $this;
  1252.     }
  1254.     public function getCategoryCnt(): ?int
  1255.     {
  1256.         return $this->categoryCnt;
  1257.     }
  1259.     public function setCategoryCnt(?int $categoryCnt): static
  1260.     {
  1261.         $this->categoryCnt = $categoryCnt;
  1263.         return $this;
  1264.     }
  1266.     public function getPriceCategory(): ?array
  1267.     {
  1268.         return $this->priceCategory;
  1269.     }
  1271.     public function setPriceCategory(?array $priceCategory): static
  1272.     {
  1273.         $this->priceCategory = $priceCategory;
  1275.         return $this;
  1276.     }
  1278.     /**
  1279.      * @return Collection<int, Comments>
  1280.      */
  1281.     public function getComments(): Collection
  1282.     {
  1283.         return $this->comments;
  1284.     }
  1286.     public function addComment(Comments $comment): static
  1287.     {
  1288.         if (!$this->comments->contains($comment)) {
  1289.             $this->comments->add($comment);
  1290.             $comment->setProduct($this);
  1291.         }
  1293.         return $this;
  1294.     }
  1296.     public function removeComment(Comments $comment): static
  1297.     {
  1298.         if ($this->comments->removeElement($comment)) {
  1299.             // set the owning side to null (unless already changed)
  1300.             if ($comment->getProduct() === $this) {
  1301.                 $comment->setProduct(null);
  1302.             }
  1303.         }
  1305.         return $this;
  1306.     }
  1308.     public function isIsSalle(): ?bool
  1309.     {
  1310.         return $this->isSalle;
  1311.     }
  1313.     public function setIsSalle(?bool $isSalle): static
  1314.     {
  1315.         $this->isSalle = $isSalle;
  1317.         return $this;
  1318.     }
  1320.     public function isIsNew(): ?bool
  1321.     {
  1322.         return $this->isNew;
  1323.     }
  1325.     public function setIsNew(?bool $isNew): static
  1326.     {
  1327.         $this->isNew = $isNew;
  1329.         return $this;
  1330.     }
  1332.     public function isIsTop(): ?bool
  1333.     {
  1334.         return $this->isTop;
  1335.     }
  1337.     public function setIsTop(?bool $isTop): static
  1338.     {
  1339.         $this->isTop = $isTop;
  1341.         return $this;
  1342.     }
  1344.     public function getMainMediaHover(): ?MediaObject
  1345.     {
  1346.         return $this->mainMediaHover;
  1347.     }
  1349.     public function setMainMediaHover(?MediaObject $mainMediaHover): static
  1350.     {
  1351.         $this->mainMediaHover = $mainMediaHover;
  1353.         return $this;
  1354.     }
  1356.     /**
  1357.      * @return Collection<int, ProductsReleted>
  1358.      */
  1359.     public function getProductsReleteds(): Collection
  1360.     {
  1361.         return $this->productsReleteds;
  1362.     }
  1364.     public function addProductsReleted(ProductsReleted $productsReleted): static
  1365.     {
  1366.         if (!$this->productsReleteds->contains($productsReleted)) {
  1367.             $this->productsReleteds->add($productsReleted);
  1368.             $productsReleted->setProduct($this);
  1369.         }
  1371.         return $this;
  1372.     }
  1374.     public function removeProductsReleted(ProductsReleted $productsReleted): static
  1375.     {
  1376.         if ($this->productsReleteds->removeElement($productsReleted)) {
  1377.             // set the owning side to null (unless already changed)
  1378.             if ($productsReleted->getProduct() === $this) {
  1379.                 $productsReleted->setProduct(null);
  1380.             }
  1381.         }
  1383.         return $this;
  1384.     }
  1386.     /**
  1387.      * @return Collection<int, ProductsReleted>
  1388.      */
  1389.     public function getParentProductRelateds(): Collection
  1390.     {
  1391.         return $this->parentProductRelateds;
  1392.     }
  1394.     public function addParentProductRelated(ProductsReleted $parentProductRelated): static
  1395.     {
  1396.         if (!$this->parentProductRelateds->contains($parentProductRelated)) {
  1397.             $this->parentProductRelateds->add($parentProductRelated);
  1398.             $parentProductRelated->setRelatedProduct($this);
  1399.         }
  1401.         return $this;
  1402.     }
  1404.     public function removeParentProductRelated(ProductsReleted $parentProductRelated): static
  1405.     {
  1406.         if ($this->parentProductRelateds->removeElement($parentProductRelated)) {
  1407.             // set the owning side to null (unless already changed)
  1408.             if ($parentProductRelated->getRelatedProduct() === $this) {
  1409.                 $parentProductRelated->setRelatedProduct(null);
  1410.             }
  1411.         }
  1413.         return $this;
  1414.     }
  1416.     public function getOldPrice(): ?float
  1417.     {
  1418.         return $this->oldPrice;
  1419.     }
  1421.     public function setOldPrice(?float $oldPrice): static
  1422.     {
  1423.         $this->oldPrice = $oldPrice;
  1425.         return $this;
  1426.     }
  1428.     public function getDiscountPercent(): ?int
  1429.     {
  1430.         return $this->discountPercent;
  1431.     }
  1433.     public function setDiscountPercent(?int $discountPercent): static
  1434.     {
  1435.         $this->discountPercent = $discountPercent;
  1437.         return $this;
  1438.     }
  1440.     public function getDateLastPriceIncome(): ?\DateTimeInterface
  1441.     {
  1442.         return $this->dateLastPriceIncome;
  1443.     }
  1445.     public function setDateLastPriceIncome(?\DateTimeInterface $dateLastPriceIncome): static
  1446.     {
  1447.         $this->dateLastPriceIncome = $dateLastPriceIncome;
  1449.         return $this;
  1450.     }
  1451. }