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', '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', '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', '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', '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', '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', 'order_product:read', 'pre_order_product:read'])]
  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.     public function __construct() {
  368.         $this->productInfos = new ArrayCollection();
  369.         $this->media = new ArrayCollection();
  370.         $this->incomingInvoiceProducts = new ArrayCollection();
  371.         $this->category = new ArrayCollection();
  372.         // $this->mediaObjects = new ArrayCollection();
  373.         $this->userLikeLists = new ArrayCollection();
  374.         $this->attributeItems = new ArrayCollection();
  375.         $this->prices = new ArrayCollection();
  376.         $this->productBalanceInStorages = new ArrayCollection();
  377.         $this->orderProducts = new ArrayCollection();
  378.         $this->products = new ArrayCollection();
  379.         $this->comments = new ArrayCollection();
  380.         $this->productsReleteds = new ArrayCollection();
  381.         $this->parentProductRelateds = new ArrayCollection();
  383.     }
  385.     public function getId(): ?int
  386.     {
  387.         return $this->id;
  388.     }
  390.     public function setId(string $id): self
  391.     {
  392.         $this->id = $id;
  394.         return $this;
  395.     }
  397.     public function getName(): ?string
  398.     {
  399.         return $this->name;
  400.     }
  402.     public function setName(string $name): self
  403.     {
  404.         $this->name = $name;
  406.         return $this;
  407.     }
  409.     public function getDateEntered(): ?\DateTimeInterface
  410.     {
  411.         return $this->date_entered;
  412.     }
  414.     // public function setDateEntered(?\DateTimeInterface $date_entered): self
  415.     // {
  416.     //     $this->date_entered = $date_entered;
  418.     //     return $this;
  419.     // }
  421.     public function getDateModified(): ?\DateTimeInterface
  422.     {
  423.         return $this->date_modified;
  424.     }
  426.     // public function setDateModified(?\DateTimeInterface $date_modified): self
  427.     // {
  428.     //     $this->date_modified = $date_modified;
  430.     //     return $this;
  431.     // }
  433.     public function getModifiedUser(): ?User
  434.     {
  435.         return $this->modified_user;
  436.     }
  438.     // public function setModifiedUserId(?User $modified_user_id): self
  439.     // {
  440.     //     $this->modified_user_id = $modified_user_id;
  442.     //     return $this;
  443.     // }
  445.     public function getCreatedBy(): ?User
  446.     {
  447.         return $this->created_by;
  448.     }
  450.     public function setCreatedBy(?User $created_by): self
  451.     {
  452.         $this->created_by = $created_by;
  454.         return $this;
  455.     }
  457.     public function getDescription(): ?string
  458.     {
  459.         return $this->description;
  460.     }
  462.     public function setDescription(?string $description): self
  463.     {
  464.         $this->description = $description;
  466.         return $this;
  467.     }
  469.     public function getCode1c(): ?string
  470.     {
  471.         return $this->code1c;
  472.     }
  474.     public function setCode1c(?string $code1c): self
  475.     {
  476.         $this->code1c = $code1c;
  478.         return $this;
  479.     }
  481.     public function getBarcode(): ?string
  482.     {
  483.         return $this->barcode;
  484.     }
  486.     public function setBarcode(?string $barcode): self
  487.     {
  488.         $this->barcode = $barcode;
  490.         return $this;
  491.     }
  493.     public function getStatus(): ?string
  494.     {
  495.         return $this->status;
  496.     }
  498.     public function setStatus(?string $status): self
  499.     {
  500.         $this->status = $status;
  502.         return $this;
  503.     }
  505.     public function getPrice(): ?float
  506.     {
  507.         return $this->price;
  508.     }
  510.     public function setPrice(?float $price): self
  511.     {
  512.         $this->price = $price;
  514.         return $this;
  515.     }
  517.     public function getPriceIncome(): ?float
  518.     {
  519.         return $this->priceIncome;
  520.     }
  522.     public function setPriceIncome(?float $priceIncome): self
  523.     {
  524.         $this->priceIncome = $priceIncome;
  526.         return $this;
  527.     }
  529.     public function getMarkUp(): ?float
  530.     {
  531.         return $this->mark_up;
  532.     }
  534.     public function setMarkUp(?float $mark_up): self
  535.     {
  536.         $this->mark_up = $mark_up;
  538.         return $this;
  539.     }
  541.     public function getMinMarkUp(): ?float
  542.     {
  543.         return $this->min_mark_up;
  544.     }
  546.     public function setMinMarkUp(float $min_mark_up): self
  547.     {
  548.         $this->min_mark_up = $min_mark_up;
  550.         return $this;
  551.     }
  553.     public function getPackingType(): ?string
  554.     {
  555.         return $this->packing_type;
  556.     }
  558.     public function setPackingType(?string $packing_type): self
  559.     {
  560.         $this->packing_type = $packing_type;
  562.         return $this;
  563.     }
  565.     public function getPackingTypeCount(): ?float
  566.     {
  567.         return $this->packing_type_count;
  568.     }
  570.     public function setPackingTypeCount(?float $packing_type_count): self
  571.     {
  572.         $this->packing_type_count = $packing_type_count;
  574.         return $this;
  575.     }
  577.     public function getDiscounts(): ?int
  578.     {
  579.         return $this->discounts;
  580.     }
  582.     public function setDiscounts(?int $discounts): self
  583.     {
  584.         $this->discounts = $discounts;
  586.         return $this;
  587.     }
  589.     public function getCountOrder(): ?int
  590.     {
  591.         return $this->count_order;
  592.     }
  594.     public function setCountOrder(?int $count_order): self
  595.     {
  596.         $this->count_order = $count_order;
  598.         return $this;
  599.     }
  601.     public function getProductToOrder(): ?int
  602.     {
  603.         return $this->productToOrder;
  604.     }
  606.     public function setProductToOrder(?int $productToOrder): self
  607.     {
  608.         $this->productToOrder = $productToOrder;
  610.         return $this;
  611.     }
  613.     public function getMeasurementUnit(): ?MeasurmentUnit
  614.     {
  615.         return $this->measurement_unit;
  616.     }
  618.     public function setMeasurementUnit(?MeasurmentUnit $measurement_unit_id): self
  619.     {
  620.         $this->measurement_unit = $measurement_unit_id;
  622.         return $this;
  623.     }
  625.     /**
  626.      * @return Collection<int, ProductInfo>
  627.      */
  628.     public function getProductInfos(): Collection
  629.     {
  630.         return $this->productInfos;
  631.     }
  633.     public function addProductInfo(ProductInfo $productInfo): self
  634.     {
  635.         if (!$this->productInfos->contains($productInfo)) {
  636.             $this->productInfos->add($productInfo);
  637.             $productInfo->setProduct($this);
  638.         }
  640.         return $this;
  641.     }
  643.     public function removeProductInfo(ProductInfo $productInfo): self
  644.     {
  645.         if ($this->productInfos->removeElement($productInfo)) {
  646.             // set the owning side to null (unless already changed)
  647.             if ($productInfo->getProduct() === $this) {
  648.                 $productInfo->setProduct(null);
  649.             }
  650.         }
  652.         return $this;
  653.     }
  655.     /**
  656.      * @return Collection<int, MediaObject>
  657.      */
  658.     public function getMedia(): Collection
  659.     {
  660.         return $this->media;
  661.     }
  663.     public function addMedium(MediaObject $medium): self
  664.     {
  665.         if (!$this->media->contains($medium)) {
  666.             $this->media->add($medium);
  667.             $medium->setProduct($this);
  668.         }
  670.         return $this;
  671.     }
  673.     public function removeMedium(MediaObject $medium): self
  674.     {
  675.         if ($this->media->removeElement($medium)) {
  676.             // set the owning side to null (unless already changed)
  677.             if ($medium->getProduct() === $this) {
  678.                 $medium->setProduct(null);
  679.             }
  680.         }
  682.         return $this;
  683.     }
  685.     /**
  686.      * @return Collection<int, IncomingInvoiceProduct>
  687.      */
  688.     public function getIncomingInvoiceProducts(): Collection
  689.     {
  690.         return $this->incomingInvoiceProducts;
  691.     }
  693.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  694.     {
  695.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  696.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  697.             $incomingInvoiceProduct->setProduct($this);
  698.         }
  700.         return $this;
  701.     }
  703.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  704.     {
  705.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  706.             // set the owning side to null (unless already changed)
  707.             if ($incomingInvoiceProduct->getProduct() === $this) {
  708.                 $incomingInvoiceProduct->setProduct(null);
  709.             }
  710.         }
  712.         return $this;
  713.     }
  715.     #[ORM\PrePersist]
  716.     public function setCreatedAtValue(): void
  717.     {
  718.         $this->date_entered = new \DateTime();
  719.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', $this->getCurrentUserId() . "\n", FILE_APPEND);
  720.         $this->created_by = $this->getCurrentUserId();
  721.     }
  723.     // #[ORM\PrePersist]
  724.     #[ORM\PreUpdate]
  725.     public function setUpdatedAtValue(): void
  726.     {
  727.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', "222222\n", FILE_APPEND);
  728.         $this->date_modified = new \DateTime();
  729.         $this->modified_user = $this->getCurrentUserId();
  730.     }
  732.     public function getCurrentUserId(): ?User
  733.     {
  734.         file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', print_r($this->security, true)."\n", FILE_APPEND);
  735.         if (!$this->security) {
  736.             return null;
  737.         }
  739.         $token = $this->security->getToken();
  740.         if (!$token) {
  741.             return null;
  742.         }
  744.         $user = $token->getUser();
  745.         if (!$user instanceof User) {
  746.             return null;
  747.         }
  749.         return $user;
  750.     }
  752.     public function __sleep()
  753.     {
  754.         return [
  755.             'modified_user',
  756.             // 'created_by',
  757.             // 'date_entered',
  758.             'date_modified'
  759.         ];
  760.     }
  762.     public function __wakeup(): void
  763.     {
  764.         $this->security = null;
  765.     }
  767.     public function getArticle(): ?string
  768.     {
  769.         return $this->article;
  770.     }
  772.     public function setArticle(?string $article): self
  773.     {
  774.         $this->article = $article;
  776.         return $this;
  777.     }
  779.     public function getNds(): ?float
  780.     {
  781.         return $this->nds;
  782.     }
  784.     public function setNds(?float $nds): self
  785.     {
  786.         $this->nds = $nds;
  788.         return $this;
  789.     }
  791.     public function isService(): ?bool
  792.     {
  793.         return $this->service;
  794.     }
  796.     public function setService(?bool $service): self
  797.     {
  798.         $this->service = $service;
  800.         return $this;
  801.     }
  803.     public function isTransportService(): ?bool
  804.     {
  805.         return $this->transport_service;
  806.     }
  808.     public function setTransportService(?bool $transport_service): self
  809.     {
  810.         $this->transport_service = $transport_service;
  812.         return $this;
  813.     }
  815.     public function isExise(): ?bool
  816.     {
  817.         return $this->exise;
  818.     }
  820.     public function setExise(bool $exise): self
  821.     {
  822.         $this->exise = $exise;
  824.         return $this;
  825.     }
  827.     public function isExpirationDate(): ?bool
  828.     {
  829.         return $this->expiration_date;
  830.     }
  832.     public function setExpirationDate(?bool $expiration_date): self
  833.     {
  834.         $this->expiration_date = $expiration_date;
  836.         return $this;
  837.     }
  839.     public function getUnitVolume(): ?float
  840.     {
  841.         return $this->unit_volume;
  842.     }
  844.     public function setUnitVolume(?float $unit_volume): self
  845.     {
  846.         $this->unit_volume = $unit_volume;
  848.         return $this;
  849.     }
  851.     public function getNetWeight(): ?float
  852.     {
  853.         return $this->net_weight;
  854.     }
  856.     public function setNetWeight(?float $net_weight): self
  857.     {
  858.         $this->net_weight = $net_weight;
  860.         return $this;
  861.     }
  863.     public function getGrossWeight(): ?float
  864.     {
  865.         return $this->gross_weight;
  866.     }
  868.     public function setGrossWeight(?float $gross_weight): self
  869.     {
  870.         $this->gross_weight = $gross_weight;
  872.         return $this;
  873.     }
  875.     public function isGoByWeight(): ?bool
  876.     {
  877.         return $this->go_by_weight;
  878.     }
  880.     public function setGoByWeight(?bool $go_by_weight): self
  881.     {
  882.         $this->go_by_weight = $go_by_weight;
  884.         return $this;
  885.     }
  887.     public function getPackaging(): ?float
  888.     {
  889.         return $this->packaging;
  890.     }
  892.     public function setPackaging(?float $packaging): self
  893.     {
  894.         $this->packaging = $packaging;
  896.         return $this;
  897.     }
  899.     public function getSiteProduct(): ?SiteProducts
  900.     {
  901.         return $this->siteProduct;
  902.     }
  904.     public function setSiteProduct(?SiteProducts $siteProduct): self
  905.     {
  906.         $this->siteProduct = $siteProduct;
  908.         return $this;
  909.     }
  911.     /**
  912.      * @return Collection<int, Category>
  913.      */
  914.     public function getCategory(): Collection
  915.     {
  916.         return $this->category;
  917.     }
  919.     public function addCategory(Category $category): self
  920.     {
  921.         if (!$this->category->contains($category)) {
  922.             $this->category->add($category);
  923.         }
  925.         return $this;
  926.     }
  928.     public function removeCategory(Category $category): self
  929.     {
  930.         $this->category->removeElement($category);
  932.         return $this;
  933.     }
  935.     /**
  936.      * @return Collection<int, MediaObject>
  937.      */
  938.     public function getMediaObjects(): Collection
  939.     {
  940.         return $this->mediaObjects;
  941.     }
  943.     public function addMediaObject(MediaObject $mediaObject): self
  944.     {
  945.         if (!$this->mediaObjects->contains($mediaObject)) {
  946.             $this->mediaObjects->add($mediaObject);
  947.             $mediaObject->setProduct($this);
  948.         }
  950.         return $this;
  951.     }
  953.     public function removeMediaObject(MediaObject $mediaObject): self
  954.     {
  955.         if ($this->mediaObjects->removeElement($mediaObject)) {
  956.             // set the owning side to null (unless already changed)
  957.             if ($mediaObject->getProduct() === $this) {
  958.                 $mediaObject->setProduct(null);
  959.             }
  960.         }
  962.         return $this;
  963.     }
  965.     public function getOldCode(): ?string
  966.     {
  967.         return $this->oldCode;
  968.     }
  970.     public function setOldCode(string $oldCode): self
  971.     {
  972.         $this->oldCode = $oldCode;
  974.         return $this;
  975.     }
  977.     /**
  978.      * @return Collection<int, UserLikeList>
  979.      */
  980.     public function getUserLikeLists(): Collection
  981.     {
  982.         return $this->userLikeLists;
  983.     }
  985.     public function addUserLikeList(UserLikeList $userLikeList): self
  986.     {
  987.         if (!$this->userLikeLists->contains($userLikeList)) {
  988.             $this->userLikeLists->add($userLikeList);
  989.             $userLikeList->setз�product($this);
  990.         }
  992.         return $this;
  993.     }
  995.     public function removeUserLikeList(UserLikeList $userLikeList): self
  996.     {
  997.         if ($this->userLikeLists->removeElement($userLikeList)) {
  998.             // set the owning side to null (unless already changed)
  999.             if ($userLikeList->getз�product() === $this) {
  1000.                 $userLikeList->setз�product(null);
  1001.             }
  1002.         }
  1004.         return $this;
  1005.     }
  1007.     /**
  1008.      * @return Collection<int, AttributeItems>
  1009.      */
  1010.     public function getAttributeItems(): Collection
  1011.     {
  1012.         return $this->attributeItems;
  1013.     }
  1015.     public function addAttributeItem(AttributeItems $attributeItem): self
  1016.     {
  1017.         if (!$this->attributeItems->contains($attributeItem)) {
  1018.             $this->attributeItems->add($attributeItem);
  1019.             $attributeItem->addProduct($this);
  1020.         }
  1022.         return $this;
  1023.     }
  1025.     public function removeAttributeItem(AttributeItems $attributeItem): self
  1026.     {
  1027.         if ($this->attributeItems->removeElement($attributeItem)) {
  1028.             $attributeItem->removeProduct($this);
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function isShow(): ?bool
  1035.     {
  1036.         return $this->show;
  1037.     }
  1039.     public function setShow(?bool $show): self
  1040.     {
  1041.         $this->show = $show;
  1043.         return $this;
  1044.     }
  1046.     public function getStorage(): ?Storage
  1047.     {
  1048.         return $this->storage;
  1049.     }
  1051.     public function setStorage(?Storage $storage): self
  1052.     {
  1053.         $this->storage = $storage;
  1055.         return $this;
  1056.     }
  1058.     public function getStorageElement(): ?StorageElement
  1059.     {
  1060.         return $this->storageElement;
  1061.     }
  1063.     public function setStorageElement(?StorageElement $storageElement): self
  1064.     {
  1065.         $this->storageElement = $storageElement;
  1067.         return $this;
  1068.     }
  1069.     
  1070.     /**
  1071.      * @return Collection<int, Prices>
  1072.      */
  1073.     public function getPrices(): Collection
  1074.     {
  1075.         return $this->prices;
  1076.     }
  1078.     public function addPrice(Prices $price): static
  1079.     {
  1080.         if (!$this->prices->contains($price)) {
  1081.             $this->prices->add($price);
  1082.             $price->setAgreement($this);
  1083.         }
  1085.         return $this;
  1086.     }
  1088.     public function removePrice(Prices $price): static
  1089.     {
  1090.         if ($this->prices->removeElement($price)) {
  1091.             // set the owning side to null (unless already changed)
  1092.             if ($price->getAgreement() === $this) {
  1093.                 $price->setAgreement(null);
  1094.             }
  1095.         }
  1097.         return $this;
  1098.     }
  1100.     /**
  1101.      * @return Collection<int, ProductBalanceInStorage>
  1102.      */
  1103.     public function getProductBalanceInStorages(): Collection
  1104.     {
  1105.         return $this->productBalanceInStorages;
  1106.     }
  1108.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1109.     {
  1110.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  1111.             $this->productBalanceInStorages->add($productBalanceInStorage);
  1112.             $productBalanceInStorage->setProduct($this);
  1113.         }
  1115.         return $this;
  1116.     }
  1118.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1119.     {
  1120.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  1121.             // set the owning side to null (unless already changed)
  1122.             if ($productBalanceInStorage->getProduct() === $this) {
  1123.                 $productBalanceInStorage->setProduct(null);
  1124.             }
  1125.         }
  1127.         return $this;
  1128.     }
  1130.     public function getBalance(): ?float
  1131.     {
  1132.         return $this->balance;
  1133.     }
  1135.     public function setBalance(?float $balance): self
  1136.     {
  1137.         $this->balance = $balance;
  1139.         return $this;
  1140.     }
  1142.     /**
  1143.      * @return Collection<int, OrderProduct>
  1144.      */
  1145.     public function getOrderProducts(): Collection
  1146.     {
  1147.         return $this->orderProducts;
  1148.     }
  1150.     public function addOrderProduct(OrderProduct $orderProduct): self
  1151.     {
  1152.         if (!$this->orderProducts->contains($orderProduct)) {
  1153.             $this->orderProducts->add($orderProduct);
  1154.             $orderProduct->setOrder($this);
  1155.         }
  1157.         return $this;
  1158.     }
  1160.     public function removeOrderProduct(OrderProduct $orderProduct): self
  1161.     {
  1162.         if ($this->orderProducts->removeElement($orderProduct)) {
  1163.             // set the owning side to null (unless already changed)
  1164.             if ($orderProduct->getOrder() === $this) {
  1165.                 $orderProduct->setOrder(null);
  1166.             }
  1167.         }
  1169.         return $this;
  1170.     }
  1172.     public function getLanguage(): ?Languages
  1173.     {
  1174.         return $this->language;
  1175.     }
  1177.     public function setLanguage(?Languages $language): self
  1178.     {
  1179.         $this->language = $language;
  1181.         return $this;
  1182.     }
  1184.     public function getTranslations(): ?self
  1185.     {
  1186.         return $this->translations;
  1187.     }
  1189.     public function setTranslations(?self $translations): self
  1190.     {
  1191.         $this->translations = $translations;
  1193.         return $this;
  1194.     }
  1196.     /**
  1197.      * @return Collection<int, self>
  1198.      */
  1199.     public function getProducts(): Collection
  1200.     {
  1201.         return $this->products;
  1202.     }
  1204.     public function addProduct(self $product): self
  1205.     {
  1206.         if (!$this->products->contains($product)) {
  1207.             $this->products->add($product);
  1208.             $product->setTranslations($this);
  1209.         }
  1211.         return $this;
  1212.     }
  1214.     public function removeProduct(self $product): self
  1215.     {
  1216.         if ($this->products->removeElement($product)) {
  1217.             // set the owning side to null (unless already changed)
  1218.             if ($product->getTranslations() === $this) {
  1219.                 $product->setTranslations(null);
  1220.             }
  1221.         }
  1223.         return $this;
  1224.     }
  1226.     public function getMainMedia(): ?MediaObject
  1227.     {
  1228.         return $this->mainMedia;
  1229.     }
  1231.     public function setMainMedia(?MediaObject $mainMedia): self
  1232.     {
  1233.         $this->mainMedia = $mainMedia;
  1235.         return $this;
  1236.     }
  1238.     public function isDeleted(): ?bool
  1239.     {
  1240.         return $this->deleted;
  1241.     }
  1243.     public function setDeleted(?bool $deleted): static
  1244.     {
  1245.         $this->deleted = $deleted;
  1247.         return $this;
  1248.     }
  1250.     public function getCategoryCnt(): ?int
  1251.     {
  1252.         return $this->categoryCnt;
  1253.     }
  1255.     public function setCategoryCnt(?int $categoryCnt): static
  1256.     {
  1257.         $this->categoryCnt = $categoryCnt;
  1259.         return $this;
  1260.     }
  1262.     public function getPriceCategory(): ?array
  1263.     {
  1264.         return $this->priceCategory;
  1265.     }
  1267.     public function setPriceCategory(?array $priceCategory): static
  1268.     {
  1269.         $this->priceCategory = $priceCategory;
  1271.         return $this;
  1272.     }
  1274.     /**
  1275.      * @return Collection<int, Comments>
  1276.      */
  1277.     public function getComments(): Collection
  1278.     {
  1279.         return $this->comments;
  1280.     }
  1282.     public function addComment(Comments $comment): static
  1283.     {
  1284.         if (!$this->comments->contains($comment)) {
  1285.             $this->comments->add($comment);
  1286.             $comment->setProduct($this);
  1287.         }
  1289.         return $this;
  1290.     }
  1292.     public function removeComment(Comments $comment): static
  1293.     {
  1294.         if ($this->comments->removeElement($comment)) {
  1295.             // set the owning side to null (unless already changed)
  1296.             if ($comment->getProduct() === $this) {
  1297.                 $comment->setProduct(null);
  1298.             }
  1299.         }
  1301.         return $this;
  1302.     }
  1304.     public function isIsSalle(): ?bool
  1305.     {
  1306.         return $this->isSalle;
  1307.     }
  1309.     public function setIsSalle(?bool $isSalle): static
  1310.     {
  1311.         $this->isSalle = $isSalle;
  1313.         return $this;
  1314.     }
  1316.     public function isIsNew(): ?bool
  1317.     {
  1318.         return $this->isNew;
  1319.     }
  1321.     public function setIsNew(?bool $isNew): static
  1322.     {
  1323.         $this->isNew = $isNew;
  1325.         return $this;
  1326.     }
  1328.     public function isIsTop(): ?bool
  1329.     {
  1330.         return $this->isTop;
  1331.     }
  1333.     public function setIsTop(?bool $isTop): static
  1334.     {
  1335.         $this->isTop = $isTop;
  1337.         return $this;
  1338.     }
  1340.     public function getMainMediaHover(): ?MediaObject
  1341.     {
  1342.         return $this->mainMediaHover;
  1343.     }
  1345.     public function setMainMediaHover(?MediaObject $mainMediaHover): static
  1346.     {
  1347.         $this->mainMediaHover = $mainMediaHover;
  1349.         return $this;
  1350.     }
  1352.     /**
  1353.      * @return Collection<int, ProductsReleted>
  1354.      */
  1355.     public function getProductsReleteds(): Collection
  1356.     {
  1357.         return $this->productsReleteds;
  1358.     }
  1360.     public function addProductsReleted(ProductsReleted $productsReleted): static
  1361.     {
  1362.         if (!$this->productsReleteds->contains($productsReleted)) {
  1363.             $this->productsReleteds->add($productsReleted);
  1364.             $productsReleted->setProduct($this);
  1365.         }
  1367.         return $this;
  1368.     }
  1370.     public function removeProductsReleted(ProductsReleted $productsReleted): static
  1371.     {
  1372.         if ($this->productsReleteds->removeElement($productsReleted)) {
  1373.             // set the owning side to null (unless already changed)
  1374.             if ($productsReleted->getProduct() === $this) {
  1375.                 $productsReleted->setProduct(null);
  1376.             }
  1377.         }
  1379.         return $this;
  1380.     }
  1382.     /**
  1383.      * @return Collection<int, ProductsReleted>
  1384.      */
  1385.     public function getParentProductRelateds(): Collection
  1386.     {
  1387.         return $this->parentProductRelateds;
  1388.     }
  1390.     public function addParentProductRelated(ProductsReleted $parentProductRelated): static
  1391.     {
  1392.         if (!$this->parentProductRelateds->contains($parentProductRelated)) {
  1393.             $this->parentProductRelateds->add($parentProductRelated);
  1394.             $parentProductRelated->setRelatedProduct($this);
  1395.         }
  1397.         return $this;
  1398.     }
  1400.     public function removeParentProductRelated(ProductsReleted $parentProductRelated): static
  1401.     {
  1402.         if ($this->parentProductRelateds->removeElement($parentProductRelated)) {
  1403.             // set the owning side to null (unless already changed)
  1404.             if ($parentProductRelated->getRelatedProduct() === $this) {
  1405.                 $parentProductRelated->setRelatedProduct(null);
  1406.             }
  1407.         }
  1409.         return $this;
  1410.     }
  1412.     public function getOldPrice(): ?float
  1413.     {
  1414.         return $this->oldPrice;
  1415.     }
  1417.     public function setOldPrice(?float $oldPrice): static
  1418.     {
  1419.         $this->oldPrice = $oldPrice;
  1421.         return $this;
  1422.     }
  1424.     public function getDiscountPercent(): ?int
  1425.     {
  1426.         return $this->discountPercent;
  1427.     }
  1429.     public function setDiscountPercent(?int $discountPercent): static
  1430.     {
  1431.         $this->discountPercent = $discountPercent;
  1433.         return $this;
  1434.     }
  1435. }