src/Entity/Products.php line 106

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\ProductsRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\Security\Core\Security;
  12. use Symfony\Component\Security\Core\SecurityInterface;
  13. use DateTimeImmutable;
  14. use ApiPlatform\Metadata\ApiFilter;
  15. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  16. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\BooleanFilter;
  17. use ApiPlatform\Metadata\Get;
  18. use ApiPlatform\Metadata\GetCollection;
  19. use ApiPlatform\Metadata\Delete;
  20. use ApiPlatform\Metadata\Put;
  21. use ApiPlatform\Metadata\Post;
  22. use App\Controller\BatchCreateProductAction;
  23. use App\Controller\ProductController;
  24. use Symfony\Component\Serializer\Annotation\Groups;
  25. use ApiPlatform\Core\Annotation\ApiProperty; 
  26. use Symfony\Component\Serializer\Annotation\MaxDepth;
  27. use App\Filter\ShowProductsFilter;
  28. use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
  29. use ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
  30. use App\Filter\CustomOrFilter; 
  31. use App\Filter\AttributeFilter; 
  32. use App\Filter\DeletedFilter; 
  33. use Doctrine\ORM\Mapping\Index;
  34. use ApiPlatform\Serializer\Filter\GroupFilter;
  35. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\ExistsFilter;
  38. #[ORM\Entity(repositoryClass: ProductsRepository::class)]
  39. #[ApiResource(
  40.     operations: [
  41.         new Get(),
  42.         new Post(),
  43.         new Delete(),
  44.         new GetCollection(),
  45.         new Put(),
  46.         new Post(
  47.             name: 'batch', 
  48.             uriTemplate: '/products/batch', 
  49.             controller: BatchCreateProductAction::class
  50.         ),
  51.         new Get(
  52.             name: 'filter_product', 
  53.             uriTemplate: '/products/filter', 
  54.             controller: ProductController::class
  55.         )
  56.     ],
  57.     normalizationContext: ['groups' => ['product:read', 'prod:medium']],
  58.     denormalizationContext: ['groups' => ['product:write']],
  59.     order: ['name' => 'ASC', 'media.sort' => 'DESC', 'discontinued' => 'DESC'],
  60.     // paginationPartial: true,
  61.     // paginationEnabled: true,
  62.     // filters: [ShowProductsFilter::class] 
  63. )]
  64. // #[Get]
  65. #[ORM\HasLifecycleCallbacks]
  67. #[ApiFilter(RangeFilter::class, properties: ['balance', 'price'])]
  69. #[ApiFilter(DeletedFilter::class)]
  71. #[ApiFilter(
  72.     SearchFilter::class, 
  73.     properties: [
  74.         'id' => 'exact', 
  75.         'oldCode' => 'exact', 
  76.         'code1c' => 'exact', 
  77.         'top' => 'exact', 
  78.         'productToOrder' => 'exact', 
  79.         'name' => 'ipartial', 
  80.         'barcode' => 'exact', 
  81.         'category.id' => 'exact',
  82.         'category.slug' => 'exact',
  83.         'category.type' => 'exact',
  84.         'attributeItems.id' => 'exact',
  85.         'show' => 'exact',
  86.         'article' => 'exact',
  87.         'prices.product' => 'exact',
  88.         'prices.agreement.virtual' => 'exact',
  89.         'prices.agreement.account.id' => 'exact',
  90.         'productBalanceInStorages.manager.id' => 'exact',
  91.         'orderProducts.order.account.id' => 'exact',
  92.         'orderProducts.order.account.user.id' => 'exact',
  93.         'categoryCnt' => 'exact',
  94.         'deleted' => 'exact',
  95.         'isSalle' => 'exact',
  96.         'isNew' => 'exact',
  97.         'isTop' => 'exact',
  98.         'category.slug' => 'exact',
  99.         'translation' => 'exact',
  100.         'language' => 'exact',
  101.         'discontinued' => 'exact',
  102.     ],
  103. )]
  105. #[ApiFilter(AttributeFilter::class)]
  107. #[ApiFilter(OrderFilter::class, properties: ['price', 'name'], arguments: ['orderParameterName' => 'order'])]
  109. #[Index(name: "show", columns: ["show", "deleted"])]
  111. #[ApiFilter(GroupFilter::class, arguments: ['parameterName' => 'g', 'overrideDefaultGroups' => true])]
  113. #[ApiFilter(ExistsFilter::class, properties: ['attributeItems'])]
  115. class Products
  116. {
  117.     #[ORM\Id]
  118.     #[ORM\GeneratedValue]
  119.     #[ORM\Column]
  120.     #[Groups(['product:read', 'product:admin', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  121.     private ?int $id = null;
  123.     #[ORM\Column(length: 255)]
  124.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  125.     private ?string $name = null;
  127.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  128.     #[Groups(['product:admin'])]
  129.     private ?\DateTimeInterface $date_entered;
  131.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  132.     #[Groups(['product:admin'])]
  133.     private ?\DateTimeInterface $date_modified;
  135.     #[ORM\ManyToOne(inversedBy: 'products')]
  136.     #[Groups(['product:modified_user'])]
  137.     #[MaxDepth(1)]
  138.     private ?User $modified_user = null;
  140.     #[ORM\ManyToOne(inversedBy: 'create_products')]
  141.     #[Groups(['product:created_by'])]
  142.     #[MaxDepth(1)]
  143.     private ?User $created_by;
  145.     #[Groups(['product:read', 'product:write', 'site_product:read'])]
  146.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  147.     private ?string $description = null;
  149.     #[ORM\Column(length: 20, nullable: true)]
  150.     #[Groups([ 'product:admin', 'product:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read'])]
  151.     private ?string $code1c = null;
  153.     #[ORM\Column(length: 100, nullable: true)]
  154.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  155.     private ?string $barcode = null;
  157.     #[ORM\Column(length: 100, nullable: true)]
  158.     #[Groups(['product:read', 'product:write'])]
  159.     private ?string $status = null;
  161.     #[ORM\Column(nullable: true)]
  162.     #[Groups(['product:read', 'product:write', 'order_product:read', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'attributes_items:read',   'cat:read','product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  163.     private ?float $price = null;
  165.     #[ORM\Column(nullable: true)]
  166.     #[Groups([ 'product:admin', 'product:write', 'order_product:read', 'product_releted:read'])]
  167.     private ?float $priceIncome = null;
  169.     #[ORM\Column(nullable: true)]
  170.     #[Groups(['product:admin', 'product:write'])]
  171.     private ?float $mark_up = null;
  173.     #[ORM\Column]
  174.     #[Groups(['product:admin', 'product:write'])]
  175.     private ?float $min_mark_up = 1;
  177.     #[ORM\Column(length: 100, nullable: true)]
  178.     #[Groups(['product:write'])]
  179.     private ?string $packing_type = null;
  181.     #[ORM\Column(nullable: true)]
  182.     #[Groups(['product:write'])]
  183.     private ?float $packing_type_count = null;
  185.     #[ORM\Column(nullable: true)]
  186.     #[Groups(['product:read', 'product:write', 'order_product:read', 'product_releted:read'])]
  187.     private ?int $discounts = null;
  189.     #[ORM\Column(nullable: true)]
  190.     #[Groups(['product:admin', 'product:write'])]
  191.     private ?int $count_order = null;
  193.     #[ORM\Column(nullable: true)]
  194.     #[Groups(['product:read', 'product:write'])]
  195.     private ?int $productToOrder = null;
  197.     #[ORM\ManyToOne]
  198.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read'])]
  199.     #[ApiProperty(writable: true)]
  200.     #[MaxDepth(1)]
  201.     private ?MeasurmentUnit $measurement_unit = null;
  203.     #[Groups(['product:productInfos', 'product:write', 'site_product:read'])]
  204.     #[MaxDepth(1)]
  205.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductInfo::class,)]
  206.     private ?Collection $productInfos = null;
  208.     #[MaxDepth(1)]
  209.     #[Groups(['product:media', 'product:write', 'cat:read', 'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
  210.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: MediaObject::class)]
  211.     private Collection $media;
  213.     #[MaxDepth(2)]
  214.     #[Groups(['product:incomingInvoiceProducts', 'product:write'])]
  215.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: IncomingInvoiceProduct::class)]
  216.     private Collection $incomingInvoiceProducts;
  217.     
  218.     private ?SecurityInterface $security = null;
  220.     #[ORM\Column(length: 20, nullable: true)]
  221.     #[Groups(['product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'product_storage_balance:read', 'site_product:read', 'product_releted:read'])]
  222.     private ?string $article = null;
  224.     #[ORM\Column(nullable: true)]
  225.     #[Groups(['product:admin', 'product:write'])]
  226.     private ?float $nds = null;
  228.     #[ORM\Column(nullable: true)]
  229.     #[Groups(['product:admin', 'product:write'])]
  230.     private ?bool $service = null;
  232.     #[ORM\Column(nullable: true)]
  233.     #[Groups(['product:admin', 'product:write'])]
  234.     private ?bool $transport_service = null;
  236.     #[ORM\Column(nullable: true)]
  237.     #[Groups(['product:read', 'product:write'])]
  238.     private ?bool $exise = false;
  240.     #[ORM\Column(nullable: true)]
  241.     #[Groups(['product:read', 'product:write'])]
  242.     private ?bool $expiration_date = null;
  244.     #[ORM\Column(nullable: true)]
  245.     #[Groups(['product:read', 'product:write'])]
  246.     private ?float $unit_volume = null;
  248.     #[ORM\Column(nullable: true)]
  249.     #[Groups(['product:read', 'product:write'])]
  250.     private ?float $net_weight = null;
  252.     #[ORM\Column(nullable: true)]
  253.     #[Groups(['product:read', 'product:write'])]
  254.     private ?float $gross_weight = null;
  256.     #[ORM\Column(nullable: true)]
  257.     #[Groups(['product:read', 'product:write'])]
  258.     private ?bool $go_by_weight = null;
  260.     #[ORM\Column(nullable: true)]
  261.     #[Groups(['product:read', 'product:write'])]
  262.     private ?float $packaging = null;
  264.     #[ORM\ManyToOne(inversedBy: 'products')]
  265.     #[MaxDepth(1)]
  266.     #[Groups(['product:siteProduct', 'product:write'])]
  267.     private ?SiteProducts $siteProduct = null;
  269.     #[Groups([ 'product:category', 'product:write'])]
  270.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
  271.     #[MaxDepth(1)]
  272.     private Collection $category;
  273.     
  274.     #[Groups(['product:admin', 'product:write'])]
  275.     #[ORM\Column(length: 100, nullable: true)]
  276.     private ?string $oldCode = null;
  278.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: UserLikeList::class)]
  279.     private Collection $userLikeLists;
  281.     #[Groups(['product:attributeItems', 'product:write', 'site_product:read'])]
  282.     #[ORM\ManyToMany(targetEntity: AttributeItems::class, mappedBy: 'product')] 
  283.     private Collection $attributeItems;
  286.     #[Groups([ 'product:read', 'product:write', 'cat:read', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
  287.     #[ORM\Column(nullable: true)]
  288.     private ?bool $show = null;
  290.     #[Groups(['product:storage', 'product:write', 'load_invoice:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'order_product:read', 'site_product:read'])]
  291.     #[ORM\ManyToOne(inversedBy: 'products')]
  292.     private ?Storage $storage = null;
  294.     #[MaxDepth(2)]
  295.     #[Groups(['product:storageElement', 'product:write','order:read', 'order_product:read'])]
  296.     #[ORM\ManyToOne(inversedBy: 'products')]
  297.     private ?StorageElement $storageElement = null;
  299.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Prices::class)]
  300.     private Collection $prices;
  302.     #[Groups(['product:productBalanceInStorages', 'product:write', 'order_product:read', 'pre_order_product:read'])]
  303.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductBalanceInStorage::class)]
  304.     private Collection $productBalanceInStorages;
  306.     #[Groups(['product:read', 'product:write', 'cat:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'user_like:read', 'order_product:read', 'attributes_items:read',   'cat:read','site_product:read'])]
  307.     #[ORM\Column(nullable: true)]
  308.     private ?float $balance = null;
  310.     #[ApiProperty(writable: true)]
  311.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderProduct::class)]
  312.     private Collection $orderProducts;
  314.     #[Groups(['product:language', 'product:write'])]
  315.     #[ORM\ManyToOne(inversedBy: 'products')]
  316.     #[MaxDepth(1)]
  317.     private ?Languages $language = null;
  319.     #[MaxDepth(1)]
  320.     #[Groups(['product:read', 'product:write', 'cat:read', 'attributes_items:read', 'attributes:read'])]
  321.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'translations')]
  322.     private ?self $translation = null;
  324.     #[MaxDepth(1)]
  325.     #[Groups(['product:read'])]
  326.     #[ORM\OneToMany(mappedBy: 'translation', targetEntity: self::class)]
  327.     private Collection $translations;
  329.     #[Groups(['product:read', 'product:write', 'cat:read', 'user_like:read', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read', 'product_releted:read'])]
  330.     #[ORM\ManyToOne(inversedBy: 'MainProducts')]
  331.     private ?MediaObject $mainMedia = null;
  333.     #[Groups(['product:admin', 'product:write'])]
  334.     #[ORM\Column(nullable: true, options: ["default" => false])]
  335.     private ?bool $deleted = false;
  337.     #[Groups(['product:admin', 'product:write'])]
  338.     #[ORM\Column(nullable: true,  options: ["default" => 0])]
  339.     private ?int $categoryCnt = 0;
  341.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  342.     #[ORM\Column(nullable: true)]
  343.     private ?array $priceCategory = null;
  345.     #[Groups(['product:comments', 'product:write'])]
  346.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Comments::class)]
  347.     private Collection $comments;
  349.     #[Groups(['product:read', 'product:write'])]
  350.     #[ORM\Column(nullable: true)]
  351.     private ?bool $isSalle = null;
  353.     #[Groups(['product:read', 'product:write'])]
  354.     #[ORM\Column(nullable: true)]
  355.     private ?bool $isNew = null;
  357.     #[Groups(['product:read', 'product:write'])]
  358.     #[ORM\Column(nullable: true)]
  359.     private ?bool $isTop = null;
  361.     #[Groups(['product:hover', 'product:write', 'product_releted:read'])]
  362.     #[ORM\ManyToOne(inversedBy: 'productsHover')]
  363.     #[ORM\JoinColumn(
  364.         name: 'main_media_hover_id',
  365.         referencedColumnName: 'id',
  366.         nullable: true,
  367.         onDelete: 'SET NULL'
  368.     )]
  369.     private ?MediaObject $mainMediaHover = null;
  371.     #[Groups(['productsReleteds:read', 'product:write'])]
  372.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductsReleted::class)]
  373.     private Collection $productsReleteds;
  375.     #[ORM\OneToMany(mappedBy: 'relatedProduct', targetEntity: ProductsReleted::class)]
  376.     private Collection $parentProductRelateds;
  378.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
  379.     #[ORM\Column(nullable: true)]
  380.     private ?float $oldPrice = null;
  382.     #[Groups(['product:read', 'product:write', 'product_releted:read'])]
  383.     #[ORM\Column(nullable: true)]
  384.     private ?int $discountPercent = null;
  386.     #[Groups(['product:read', 'product:write', 'pre_order_product:read', 'pre_order:read', 'order:read', 'order_product:read', 'site_product:read'])]
  387.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  388.     private ?\DateTimeInterface $dateLastPriceIncome = null;
  390.     #[Groups(['product:read', 'product:write'])]
  391.     #[ORM\Column(nullable: true)]
  392.     private ?array $video = null;
  394.     #[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'])]
  395.     #[ORM\Column(nullable: true)]
  396.     private ?bool $isVideo = null;
  398.     #[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'])]
  399.     #[ORM\Column(nullable: true)]
  400.     private ?bool $isFreeShipping = null;
  402.     #[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'])]
  403.     #[ORM\Column(length: 255, nullable: true)]
  404.     private ?string $warrantyPeriod = null;
  406.     #[Groups(['product:read', 'product:write'])]
  407.     #[ORM\Column(nullable: true)]
  408.     private ?float $minBalance = null;
  410.     #[Groups(['product:read', 'product:write'])]
  411.     #[ORM\Column(nullable: true)]
  412.     private ?float $minBalanceAdmin = null;
  413.     
  414.     #[Groups(['product:read', 'product:write'])]
  415.     #[ORM\Column(nullable: true)]
  416.     private ?int $mainCategoryId = null;
  418.     #[Groups(['product:read', 'product:write'])]
  419.     #[ORM\Column(nullable: true, options: ["default" => false])]
  420.     private ?bool $discontinued = null;
  422.     /**
  423.      * @var Collection<int, Documents>
  424.      */
  425.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Documents::class)]
  426.     private Collection $documents;
  428.     #[Groups(['product:read', 'product:write', 'site_product:read'])]
  429.     #[ORM\Column(length: 255, nullable: true)]
  430.     private ?string $seoTitle = null;
  432.     #[Groups(['product:read', 'product:write', 'site_product:read'])]
  433.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  434.     private ?string $seoDescription = null;
  436.     /**
  437.      * @var Collection<int, ProductDiscount>
  438.      */
  439.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductDiscount::class)]
  440.     private Collection $productDiscounts;
  442.     #[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'])]
  443.     #[ORM\Column(nullable: true)]
  444.     private ?float $sallePrice = null;
  446.     #[Groups([ 'product:admin', 'product:write', 'order_product:read', 'product_releted:read'])]
  447.     #[ORM\Column(nullable: true)]
  448.     private ?float $normalPrice = null;
  450.     public function __construct() {
  451.         $this->productInfos = new ArrayCollection();
  452.         $this->media = new ArrayCollection();
  453.         $this->incomingInvoiceProducts = new ArrayCollection();
  454.         $this->category = new ArrayCollection();
  455.         // $this->mediaObjects = new ArrayCollection();
  456.         $this->userLikeLists = new ArrayCollection();
  457.         $this->attributeItems = new ArrayCollection();
  458.         $this->prices = new ArrayCollection();
  459.         $this->productBalanceInStorages = new ArrayCollection();
  460.         $this->orderProducts = new ArrayCollection();
  461.         $this->products = new ArrayCollection();
  462.         $this->comments = new ArrayCollection();
  463.         $this->productsReleteds = new ArrayCollection();
  464.         $this->parentProductRelateds = new ArrayCollection();
  465.         // $this->mytranslations = new ArrayCollection();
  466.         $this->translations = new ArrayCollection();
  467.         $this->documents = new ArrayCollection();
  468.         $this->productDiscounts = new ArrayCollection();
  470.     }
  472.     public function getId(): ?int
  473.     {
  474.         return $this->id;
  475.     }
  477.     public function setId(string $id): self
  478.     {
  479.         $this->id = $id;
  481.         return $this;
  482.     }
  484.     public function getName(): ?string
  485.     {
  486.         return $this->name;
  487.     }
  489.     public function setName(string $name): self
  490.     {
  491.         $this->name = $name;
  493.         return $this;
  494.     }
  496.     public function getDateEntered(): ?\DateTimeInterface
  497.     {
  498.         return $this->date_entered;
  499.     }
  501.     // public function setDateEntered(?\DateTimeInterface $date_entered): self
  502.     // {
  503.     //     $this->date_entered = $date_entered;
  505.     //     return $this;
  506.     // }
  508.     public function getDateModified(): ?\DateTimeInterface
  509.     {
  510.         return $this->date_modified;
  511.     }
  513.     // public function setDateModified(?\DateTimeInterface $date_modified): self
  514.     // {
  515.     //     $this->date_modified = $date_modified;
  517.     //     return $this;
  518.     // }
  520.     public function getModifiedUser(): ?User
  521.     {
  522.         return $this->modified_user;
  523.     }
  525.     // public function setModifiedUserId(?User $modified_user_id): self
  526.     // {
  527.     //     $this->modified_user_id = $modified_user_id;
  529.     //     return $this;
  530.     // }
  532.     public function getCreatedBy(): ?User
  533.     {
  534.         return $this->created_by;
  535.     }
  537.     public function setCreatedBy(?User $created_by): self
  538.     {
  539.         $this->created_by = $created_by;
  541.         return $this;
  542.     }
  544.     public function getDescription(): ?string
  545.     {
  546.         return $this->description;
  547.     }
  549.     public function setDescription(?string $description): self
  550.     {
  551.         $this->description = $description;
  553.         return $this;
  554.     }
  556.     public function getCode1c(): ?string
  557.     {
  558.         return $this->code1c;
  559.     }
  561.     public function setCode1c(?string $code1c): self
  562.     {
  563.         $this->code1c = $code1c;
  565.         return $this;
  566.     }
  568.     public function getBarcode(): ?string
  569.     {
  570.         return $this->barcode;
  571.     }
  573.     public function setBarcode(?string $barcode): self
  574.     {
  575.         $this->barcode = $barcode;
  577.         return $this;
  578.     }
  580.     public function getStatus(): ?string
  581.     {
  582.         return $this->status;
  583.     }
  585.     public function setStatus(?string $status): self
  586.     {
  587.         $this->status = $status;
  589.         return $this;
  590.     }
  592.     public function getPrice(): ?float
  593.     {
  594.         return $this->price;
  595.     }
  597.     public function setPrice(?float $price): self
  598.     {
  599.         $this->price = $price;
  601.         return $this;
  602.     }
  604.     public function getPriceIncome(): ?float
  605.     {
  606.         return $this->priceIncome;
  607.     }
  609.     public function setPriceIncome(?float $priceIncome): self
  610.     {
  611.         $this->priceIncome = $priceIncome;
  613.         return $this;
  614.     }
  616.     public function getMarkUp(): ?float
  617.     {
  618.         return $this->mark_up;
  619.     }
  621.     public function setMarkUp(?float $mark_up): self
  622.     {
  623.         $this->mark_up = $mark_up;
  625.         return $this;
  626.     }
  628.     public function getMinMarkUp(): ?float
  629.     {
  630.         return $this->min_mark_up;
  631.     }
  633.     public function setMinMarkUp(float $min_mark_up): self
  634.     {
  635.         $this->min_mark_up = $min_mark_up;
  637.         return $this;
  638.     }
  640.     public function getPackingType(): ?string
  641.     {
  642.         return $this->packing_type;
  643.     }
  645.     public function setPackingType(?string $packing_type): self
  646.     {
  647.         $this->packing_type = $packing_type;
  649.         return $this;
  650.     }
  652.     public function getPackingTypeCount(): ?float
  653.     {
  654.         return $this->packing_type_count;
  655.     }
  657.     public function setPackingTypeCount(?float $packing_type_count): self
  658.     {
  659.         $this->packing_type_count = $packing_type_count;
  661.         return $this;
  662.     }
  664.     public function getDiscounts(): ?int
  665.     {
  666.         return $this->discounts;
  667.     }
  669.     public function setDiscounts(?int $discounts): self
  670.     {
  671.         $this->discounts = $discounts;
  673.         return $this;
  674.     }
  676.     public function getCountOrder(): ?int
  677.     {
  678.         return $this->count_order;
  679.     }
  681.     public function setCountOrder(?int $count_order): self
  682.     {
  683.         $this->count_order = $count_order;
  685.         return $this;
  686.     }
  688.     public function getProductToOrder(): ?int
  689.     {
  690.         return $this->productToOrder;
  691.     }
  693.     public function setProductToOrder(?int $productToOrder): self
  694.     {
  695.         $this->productToOrder = $productToOrder;
  697.         return $this;
  698.     }
  700.     public function getMeasurementUnit(): ?MeasurmentUnit
  701.     {
  702.         return $this->measurement_unit;
  703.     }
  705.     public function setMeasurementUnit(?MeasurmentUnit $measurement_unit_id): self
  706.     {
  707.         $this->measurement_unit = $measurement_unit_id;
  709.         return $this;
  710.     }
  712.     /**
  713.      * @return Collection<int, ProductInfo>
  714.      */
  715.     public function getProductInfos(): Collection
  716.     {
  717.         return $this->productInfos;
  718.     }
  720.     public function addProductInfo(ProductInfo $productInfo): self
  721.     {
  722.         if (!$this->productInfos->contains($productInfo)) {
  723.             $this->productInfos->add($productInfo);
  724.             $productInfo->setProduct($this);
  725.         }
  727.         return $this;
  728.     }
  730.     public function removeProductInfo(ProductInfo $productInfo): self
  731.     {
  732.         if ($this->productInfos->removeElement($productInfo)) {
  733.             // set the owning side to null (unless already changed)
  734.             if ($productInfo->getProduct() === $this) {
  735.                 $productInfo->setProduct(null);
  736.             }
  737.         }
  739.         return $this;
  740.     }
  742.     /**
  743.      * @return Collection<int, MediaObject>
  744.      */
  745.     public function getMedia(): Collection
  746.     {
  747.         return $this->media;
  748.     }
  750.     public function addMedium(MediaObject $medium): self
  751.     {
  752.         if (!$this->media->contains($medium)) {
  753.             $this->media->add($medium);
  754.             $medium->setProduct($this);
  755.         }
  757.         return $this;
  758.     }
  760.     public function removeMedium(MediaObject $medium): self
  761.     {
  762.         if ($this->media->removeElement($medium)) {
  763.             // set the owning side to null (unless already changed)
  764.             if ($medium->getProduct() === $this) {
  765.                 $medium->setProduct(null);
  766.             }
  767.         }
  769.         return $this;
  770.     }
  772.     /**
  773.      * @return Collection<int, IncomingInvoiceProduct>
  774.      */
  775.     public function getIncomingInvoiceProducts(): Collection
  776.     {
  777.         return $this->incomingInvoiceProducts;
  778.     }
  780.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  781.     {
  782.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  783.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  784.             $incomingInvoiceProduct->setProduct($this);
  785.         }
  787.         return $this;
  788.     }
  790.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  791.     {
  792.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  793.             // set the owning side to null (unless already changed)
  794.             if ($incomingInvoiceProduct->getProduct() === $this) {
  795.                 $incomingInvoiceProduct->setProduct(null);
  796.             }
  797.         }
  799.         return $this;
  800.     }
  802.     #[ORM\PrePersist]
  803.     public function setCreatedAtValue(): void
  804.     {
  805.         $this->date_entered = new \DateTime();
  806.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', $this->getCurrentUserId() . "\n", FILE_APPEND);
  807.         $this->created_by = $this->getCurrentUserId();
  808.     }
  810.     // #[ORM\PrePersist]
  811.     #[ORM\PreUpdate]
  812.     public function setUpdatedAtValue(): void
  813.     {
  814.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', "222222\n", FILE_APPEND);
  815.         $this->date_modified = new \DateTime();
  816.         $this->modified_user = $this->getCurrentUserId();
  817.     }
  819.     public function getCurrentUserId(): ?User
  820.     {
  821.         // file_put_contents('/var/www/symfony_docker/public/errorrrrrr.log', print_r($this->security, true)."\n", FILE_APPEND);
  822.         if (!$this->security) {
  823.             return null;
  824.         }
  826.         $token = $this->security->getToken();
  827.         if (!$token) {
  828.             return null;
  829.         }
  831.         $user = $token->getUser();
  832.         if (!$user instanceof User) {
  833.             return null;
  834.         }
  836.         return $user;
  837.     }
  839.     public function __sleep()
  840.     {
  841.         return [
  842.             'modified_user',
  843.             // 'created_by',
  844.             // 'date_entered',
  845.             'date_modified'
  846.         ];
  847.     }
  849.     public function __wakeup(): void
  850.     {
  851.         $this->security = null;
  852.     }
  854.     public function getArticle(): ?string
  855.     {
  856.         return $this->article;
  857.     }
  859.     public function setArticle(?string $article): self
  860.     {
  861.         $this->article = $article;
  863.         return $this;
  864.     }
  866.     public function getNds(): ?float
  867.     {
  868.         return $this->nds;
  869.     }
  871.     public function setNds(?float $nds): self
  872.     {
  873.         $this->nds = $nds;
  875.         return $this;
  876.     }
  878.     public function isService(): ?bool
  879.     {
  880.         return $this->service;
  881.     }
  883.     public function setService(?bool $service): self
  884.     {
  885.         $this->service = $service;
  887.         return $this;
  888.     }
  890.     public function isTransportService(): ?bool
  891.     {
  892.         return $this->transport_service;
  893.     }
  895.     public function setTransportService(?bool $transport_service): self
  896.     {
  897.         $this->transport_service = $transport_service;
  899.         return $this;
  900.     }
  902.     public function isExise(): ?bool
  903.     {
  904.         return $this->exise;
  905.     }
  907.     public function setExise(bool $exise): self
  908.     {
  909.         $this->exise = $exise;
  911.         return $this;
  912.     }
  914.     public function isExpirationDate(): ?bool
  915.     {
  916.         return $this->expiration_date;
  917.     }
  919.     public function setExpirationDate(?bool $expiration_date): self
  920.     {
  921.         $this->expiration_date = $expiration_date;
  923.         return $this;
  924.     }
  926.     public function getUnitVolume(): ?float
  927.     {
  928.         return $this->unit_volume;
  929.     }
  931.     public function setUnitVolume(?float $unit_volume): self
  932.     {
  933.         $this->unit_volume = $unit_volume;
  935.         return $this;
  936.     }
  938.     public function getNetWeight(): ?float
  939.     {
  940.         return $this->net_weight;
  941.     }
  943.     public function setNetWeight(?float $net_weight): self
  944.     {
  945.         $this->net_weight = $net_weight;
  947.         return $this;
  948.     }
  950.     public function getGrossWeight(): ?float
  951.     {
  952.         return $this->gross_weight;
  953.     }
  955.     public function setGrossWeight(?float $gross_weight): self
  956.     {
  957.         $this->gross_weight = $gross_weight;
  959.         return $this;
  960.     }
  962.     public function isGoByWeight(): ?bool
  963.     {
  964.         return $this->go_by_weight;
  965.     }
  967.     public function setGoByWeight(?bool $go_by_weight): self
  968.     {
  969.         $this->go_by_weight = $go_by_weight;
  971.         return $this;
  972.     }
  974.     public function getPackaging(): ?float
  975.     {
  976.         return $this->packaging;
  977.     }
  979.     public function setPackaging(?float $packaging): self
  980.     {
  981.         $this->packaging = $packaging;
  983.         return $this;
  984.     }
  986.     public function getSiteProduct(): ?SiteProducts
  987.     {
  988.         return $this->siteProduct;
  989.     }
  991.     public function setSiteProduct(?SiteProducts $siteProduct): self
  992.     {
  993.         $this->siteProduct = $siteProduct;
  995.         return $this;
  996.     }
  998.     /**
  999.      * @return Collection<int, Category>
  1000.      */
  1001.     public function getCategory(): Collection
  1002.     {
  1003.         return $this->category;
  1004.     }
  1006.     public function addCategory(Category $category): self
  1007.     {
  1008.         if (!$this->category->contains($category)) {
  1009.             $this->category->add($category);
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function removeCategory(Category $category): self
  1016.     {
  1017.         $this->category->removeElement($category);
  1019.         return $this;
  1020.     }
  1022.     /**
  1023.      * @return Collection<int, MediaObject>
  1024.      */
  1025.     public function getMediaObjects(): Collection
  1026.     {
  1027.         return $this->mediaObjects;
  1028.     }
  1030.     public function addMediaObject(MediaObject $mediaObject): self
  1031.     {
  1032.         if (!$this->mediaObjects->contains($mediaObject)) {
  1033.             $this->mediaObjects->add($mediaObject);
  1034.             $mediaObject->setProduct($this);
  1035.         }
  1037.         return $this;
  1038.     }
  1040.     public function removeMediaObject(MediaObject $mediaObject): self
  1041.     {
  1042.         if ($this->mediaObjects->removeElement($mediaObject)) {
  1043.             // set the owning side to null (unless already changed)
  1044.             if ($mediaObject->getProduct() === $this) {
  1045.                 $mediaObject->setProduct(null);
  1046.             }
  1047.         }
  1049.         return $this;
  1050.     }
  1052.     public function getOldCode(): ?string
  1053.     {
  1054.         return $this->oldCode;
  1055.     }
  1057.     public function setOldCode(string $oldCode): self
  1058.     {
  1059.         $this->oldCode = $oldCode;
  1061.         return $this;
  1062.     }
  1064.     /**
  1065.      * @return Collection<int, UserLikeList>
  1066.      */
  1067.     public function getUserLikeLists(): Collection
  1068.     {
  1069.         return $this->userLikeLists;
  1070.     }
  1072.     public function addUserLikeList(UserLikeList $userLikeList): self
  1073.     {
  1074.         if (!$this->userLikeLists->contains($userLikeList)) {
  1075.             $this->userLikeLists->add($userLikeList);
  1076.             $userLikeList->setз�product($this);
  1077.         }
  1079.         return $this;
  1080.     }
  1082.     public function removeUserLikeList(UserLikeList $userLikeList): self
  1083.     {
  1084.         if ($this->userLikeLists->removeElement($userLikeList)) {
  1085.             // set the owning side to null (unless already changed)
  1086.             if ($userLikeList->getз�product() === $this) {
  1087.                 $userLikeList->setз�product(null);
  1088.             }
  1089.         }
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, AttributeItems>
  1096.      */
  1097.     public function getAttributeItems(): Collection
  1098.     {
  1099.         return $this->attributeItems;
  1100.     }
  1102.     public function addAttributeItem(AttributeItems $attributeItem): self
  1103.     {
  1104.         if (!$this->attributeItems->contains($attributeItem)) {
  1105.             $this->attributeItems->add($attributeItem);
  1106.             $attributeItem->addProduct($this);
  1107.         }
  1109.         return $this;
  1110.     }
  1112.     public function removeAttributeItem(AttributeItems $attributeItem): self
  1113.     {
  1114.         if ($this->attributeItems->removeElement($attributeItem)) {
  1115.             $attributeItem->removeProduct($this);
  1116.         }
  1118.         return $this;
  1119.     }
  1121.     public function isShow(): ?bool
  1122.     {
  1123.         return $this->show;
  1124.     }
  1126.     public function setShow(?bool $show): self
  1127.     {
  1128.         $this->show = $show;
  1130.         return $this;
  1131.     }
  1133.     public function getStorage(): ?Storage
  1134.     {
  1135.         return $this->storage;
  1136.     }
  1138.     public function setStorage(?Storage $storage): self
  1139.     {
  1140.         $this->storage = $storage;
  1142.         return $this;
  1143.     }
  1145.     public function getStorageElement(): ?StorageElement
  1146.     {
  1147.         return $this->storageElement;
  1148.     }
  1150.     public function setStorageElement(?StorageElement $storageElement): self
  1151.     {
  1152.         $this->storageElement = $storageElement;
  1154.         return $this;
  1155.     }
  1156.     
  1157.     /**
  1158.      * @return Collection<int, Prices>
  1159.      */
  1160.     public function getPrices(): Collection
  1161.     {
  1162.         return $this->prices;
  1163.     }
  1165.     public function addPrice(Prices $price): static
  1166.     {
  1167.         if (!$this->prices->contains($price)) {
  1168.             $this->prices->add($price);
  1169.             $price->setAgreement($this);
  1170.         }
  1172.         return $this;
  1173.     }
  1175.     public function removePrice(Prices $price): static
  1176.     {
  1177.         if ($this->prices->removeElement($price)) {
  1178.             // set the owning side to null (unless already changed)
  1179.             if ($price->getAgreement() === $this) {
  1180.                 $price->setAgreement(null);
  1181.             }
  1182.         }
  1184.         return $this;
  1185.     }
  1187.     /**
  1188.      * @return Collection<int, ProductBalanceInStorage>
  1189.      */
  1190.     public function getProductBalanceInStorages(): Collection
  1191.     {
  1192.         return $this->productBalanceInStorages;
  1193.     }
  1195.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1196.     {
  1197.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  1198.             $this->productBalanceInStorages->add($productBalanceInStorage);
  1199.             $productBalanceInStorage->setProduct($this);
  1200.         }
  1202.         return $this;
  1203.     }
  1205.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  1206.     {
  1207.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  1208.             // set the owning side to null (unless already changed)
  1209.             if ($productBalanceInStorage->getProduct() === $this) {
  1210.                 $productBalanceInStorage->setProduct(null);
  1211.             }
  1212.         }
  1214.         return $this;
  1215.     }
  1217.     public function getBalance(): ?float
  1218.     {
  1219.         return $this->balance;
  1220.     }
  1222.     public function setBalance(?float $balance): self
  1223.     {
  1224.         $this->balance = $balance;
  1226.         return $this;
  1227.     }
  1229.     /**
  1230.      * @return Collection<int, OrderProduct>
  1231.      */
  1232.     public function getOrderProducts(): Collection
  1233.     {
  1234.         return $this->orderProducts;
  1235.     }
  1237.     public function addOrderProduct(OrderProduct $orderProduct): self
  1238.     {
  1239.         if (!$this->orderProducts->contains($orderProduct)) {
  1240.             $this->orderProducts->add($orderProduct);
  1241.             $orderProduct->setOrder($this);
  1242.         }
  1244.         return $this;
  1245.     }
  1247.     public function removeOrderProduct(OrderProduct $orderProduct): self
  1248.     {
  1249.         if ($this->orderProducts->removeElement($orderProduct)) {
  1250.             // set the owning side to null (unless already changed)
  1251.             if ($orderProduct->getOrder() === $this) {
  1252.                 $orderProduct->setOrder(null);
  1253.             }
  1254.         }
  1256.         return $this;
  1257.     }
  1259.     public function getLanguage(): ?Languages
  1260.     {
  1261.         return $this->language;
  1262.     }
  1264.     public function setLanguage(?Languages $language): self
  1265.     {
  1266.         $this->language = $language;
  1268.         return $this;
  1269.     }
  1273.     public function getTranslation(): ?self
  1274.     {
  1275.         return $this->translation;
  1276.     }
  1278.     public function setTranslation(?self $translation): static
  1279.     {
  1280.         $this->translation = $translation;
  1282.         return $this;
  1283.     }
  1285.     /**
  1286.      * @return Collection<int, self>
  1287.      */
  1288.     public function getTranslations(): Collection
  1289.     {
  1290.         return $this->translations;
  1291.     }
  1293.     public function addTranslation(self $translation): static
  1294.     {
  1295.         if (!$this->translations->contains($translation)) {
  1296.             $this->translations->add($translation);
  1297.             $translation->setTranslation($this);
  1298.         }
  1300.         return $this;
  1301.     }
  1303.     public function removeTranslation(self $translation): static
  1304.     {
  1305.         if ($this->translations->removeElement($translation)) {
  1306.             // set the owning side to null (unless already changed)
  1307.             if ($translation->getTranslation() === $this) {
  1308.                 $translation->setTranslation(null);
  1309.             }
  1310.         }
  1312.         return $this;
  1313.     }
  1315.     public function getMainMedia(): ?MediaObject
  1316.     {
  1317.         return $this->mainMedia;
  1318.     }
  1320.     public function setMainMedia(?MediaObject $mainMedia): self
  1321.     {
  1322.         $this->mainMedia = $mainMedia;
  1324.         return $this;
  1325.     }
  1327.     public function isDeleted(): ?bool
  1328.     {
  1329.         return $this->deleted;
  1330.     }
  1332.     public function setDeleted(?bool $deleted): static
  1333.     {
  1334.         $this->deleted = $deleted;
  1336.         return $this;
  1337.     }
  1339.     public function getCategoryCnt(): ?int
  1340.     {
  1341.         return $this->categoryCnt;
  1342.     }
  1344.     public function setCategoryCnt(?int $categoryCnt): static
  1345.     {
  1346.         $this->categoryCnt = $categoryCnt;
  1348.         return $this;
  1349.     }
  1351.     public function getPriceCategory(): ?array
  1352.     {
  1353.         return $this->priceCategory;
  1354.     }
  1356.     public function setPriceCategory(?array $priceCategory): static
  1357.     {
  1358.         $this->priceCategory = $priceCategory;
  1360.         return $this;
  1361.     }
  1363.     /**
  1364.      * @return Collection<int, Comments>
  1365.      */
  1366.     public function getComments(): Collection
  1367.     {
  1368.         return $this->comments;
  1369.     }
  1371.     public function addComment(Comments $comment): static
  1372.     {
  1373.         if (!$this->comments->contains($comment)) {
  1374.             $this->comments->add($comment);
  1375.             $comment->setProduct($this);
  1376.         }
  1378.         return $this;
  1379.     }
  1381.     public function removeComment(Comments $comment): static
  1382.     {
  1383.         if ($this->comments->removeElement($comment)) {
  1384.             // set the owning side to null (unless already changed)
  1385.             if ($comment->getProduct() === $this) {
  1386.                 $comment->setProduct(null);
  1387.             }
  1388.         }
  1390.         return $this;
  1391.     }
  1393.     public function isIsSalle(): ?bool
  1394.     {
  1395.         return $this->isSalle;
  1396.     }
  1398.     public function setIsSalle(?bool $isSalle): static
  1399.     {
  1400.         $this->isSalle = $isSalle;
  1402.         return $this;
  1403.     }
  1405.     public function isIsNew(): ?bool
  1406.     {
  1407.         return $this->isNew;
  1408.     }
  1410.     public function setIsNew(?bool $isNew): static
  1411.     {
  1412.         $this->isNew = $isNew;
  1414.         return $this;
  1415.     }
  1417.     public function isIsTop(): ?bool
  1418.     {
  1419.         return $this->isTop;
  1420.     }
  1422.     public function setIsTop(?bool $isTop): static
  1423.     {
  1424.         $this->isTop = $isTop;
  1426.         return $this;
  1427.     }
  1429.     public function getMainMediaHover(): ?MediaObject
  1430.     {
  1431.         return $this->mainMediaHover;
  1432.     }
  1434.     public function setMainMediaHover(?MediaObject $mainMediaHover): static
  1435.     {
  1436.         $this->mainMediaHover = $mainMediaHover;
  1438.         return $this;
  1439.     }
  1441.     /**
  1442.      * @return Collection<int, ProductsReleted>
  1443.      */
  1444.     public function getProductsReleteds(): Collection
  1445.     {
  1446.         return $this->productsReleteds;
  1447.     }
  1449.     public function addProductsReleted(ProductsReleted $productsReleted): static
  1450.     {
  1451.         if (!$this->productsReleteds->contains($productsReleted)) {
  1452.             $this->productsReleteds->add($productsReleted);
  1453.             $productsReleted->setProduct($this);
  1454.         }
  1456.         return $this;
  1457.     }
  1459.     public function removeProductsReleted(ProductsReleted $productsReleted): static
  1460.     {
  1461.         if ($this->productsReleteds->removeElement($productsReleted)) {
  1462.             // set the owning side to null (unless already changed)
  1463.             if ($productsReleted->getProduct() === $this) {
  1464.                 $productsReleted->setProduct(null);
  1465.             }
  1466.         }
  1468.         return $this;
  1469.     }
  1471.     /**
  1472.      * @return Collection<int, ProductsReleted>
  1473.      */
  1474.     public function getParentProductRelateds(): Collection
  1475.     {
  1476.         return $this->parentProductRelateds;
  1477.     }
  1479.     public function addParentProductRelated(ProductsReleted $parentProductRelated): static
  1480.     {
  1481.         if (!$this->parentProductRelateds->contains($parentProductRelated)) {
  1482.             $this->parentProductRelateds->add($parentProductRelated);
  1483.             $parentProductRelated->setRelatedProduct($this);
  1484.         }
  1486.         return $this;
  1487.     }
  1489.     public function removeParentProductRelated(ProductsReleted $parentProductRelated): static
  1490.     {
  1491.         if ($this->parentProductRelateds->removeElement($parentProductRelated)) {
  1492.             // set the owning side to null (unless already changed)
  1493.             if ($parentProductRelated->getRelatedProduct() === $this) {
  1494.                 $parentProductRelated->setRelatedProduct(null);
  1495.             }
  1496.         }
  1498.         return $this;
  1499.     }
  1501.     public function getOldPrice(): ?float
  1502.     {
  1503.         return $this->oldPrice;
  1504.     }
  1506.     public function setOldPrice(?float $oldPrice): static
  1507.     {
  1508.         $this->oldPrice = $oldPrice;
  1510.         return $this;
  1511.     }
  1513.     public function getDiscountPercent(): ?int
  1514.     {
  1515.         return $this->discountPercent;
  1516.     }
  1518.     public function setDiscountPercent(?int $discountPercent): static
  1519.     {
  1520.         $this->discountPercent = $discountPercent;
  1522.         return $this;
  1523.     }
  1525.     public function getDateLastPriceIncome(): ?\DateTimeInterface
  1526.     {
  1527.         return $this->dateLastPriceIncome;
  1528.     }
  1530.     public function setDateLastPriceIncome(?\DateTimeInterface $dateLastPriceIncome): static
  1531.     {
  1532.         $this->dateLastPriceIncome = $dateLastPriceIncome;
  1533.         
  1534.         return $this;
  1535.     }
  1536.     
  1537.     public function getVideo(): ?array
  1538.     {
  1539.         return $this->video;
  1540.     }
  1542.     public function setVideo(?array $video): static
  1543.     {
  1544.         $this->video = $video;
  1546.         return $this;
  1547.     }
  1549.     public function isIsVideo(): ?bool
  1550.     {
  1551.         return $this->isVideo;
  1552.     }
  1554.     public function setIsVideo(?bool $isVideo): static
  1555.     {
  1556.         $this->isVideo = $isVideo;
  1558.         return $this;
  1559.     }
  1561.     public function isIsFreeShipping(): ?bool
  1562.     {
  1563.         return $this->isFreeShipping;
  1564.     }
  1566.     public function setIsFreeShipping(?bool $isFreeShipping): static
  1567.     {
  1568.         $this->isFreeShipping = $isFreeShipping;
  1570.         return $this;
  1571.     }
  1573.     public function getWarrantyPeriod(): ?string
  1574.     {
  1575.         return $this->warrantyPeriod;
  1576.     }
  1578.     public function setWarrantyPeriod(?string $warrantyPeriod): static
  1579.     {
  1580.         $this->warrantyPeriod = $warrantyPeriod;
  1582.         return $this;
  1583.     }
  1585.     public function getMinBalance(): ?float
  1586.     {
  1587.         return $this->minBalance;
  1588.     }
  1590.     public function setMinBalance(?float $minBalance): static
  1591.     {
  1592.         $this->minBalance = $minBalance;
  1594.         return $this;
  1595.     }
  1597.     public function getMinBalanceAdmin(): ?float
  1598.     {
  1599.         return $this->minBalanceAdmin;
  1600.     }
  1602.     public function setMinBalanceAdmin(?float $minBalanceAdmin): static
  1603.     {
  1604.         $this->minBalanceAdmin = $minBalanceAdmin;
  1606.         return $this;
  1607.     }
  1609.     public function getMainCategoryId(): ?int
  1610.     {
  1611.         return $this->mainCategoryId;
  1612.     }
  1614.     public function setMainCategoryId(?int $mainCategoryId): static
  1615.     {
  1616.         $this->mainCategoryId = $mainCategoryId;
  1618.         return $this;
  1619.     }
  1621.     public function isDiscontinued(): ?bool
  1622.     {
  1623.         return $this->discontinued;
  1624.     }
  1626.     public function setDiscontinued(?bool $discontinued): static
  1627.     {
  1628.         $this->discontinued = $discontinued;
  1630.         return $this;
  1631.     }
  1633.     /**
  1634.      * @return Collection<int, Documents>
  1635.      */
  1636.     public function getDocuments(): Collection
  1637.     {
  1638.         return $this->documents;
  1639.     }
  1641.     public function addDocument(Documents $document): static
  1642.     {
  1643.         if (!$this->documents->contains($document)) {
  1644.             $this->documents->add($document);
  1645.             $document->setProduct($this);
  1646.         }
  1648.         return $this;
  1649.     }
  1651.     public function removeDocument(Documents $document): static
  1652.     {
  1653.         if ($this->documents->removeElement($document)) {
  1654.             // set the owning side to null (unless already changed)
  1655.             if ($document->getProduct() === $this) {
  1656.                 $document->setProduct(null);
  1657.             }
  1658.         }
  1660.         return $this;
  1661.     }
  1663.     public function getSeoTitle(): ?string
  1664.     {
  1665.         return $this->seoTitle;
  1666.     }
  1668.     public function setSeoTitle(?string $seoTitle): static
  1669.     {
  1670.         $this->seoTitle = $seoTitle;
  1672.         return $this;
  1673.     }
  1675.     public function getSeoDescription(): ?string
  1676.     {
  1677.         return $this->seoDescription;
  1678.     }
  1680.     public function setSeoDescription(?string $seoDescription): static
  1681.     {
  1682.         $this->seoDescription = $seoDescription;
  1684.         return $this;
  1685.     }
  1687.     /**
  1688.      * @return Collection<int, ProductDiscount>
  1689.      */
  1690.     public function getProductDiscounts(): Collection
  1691.     {
  1692.         return $this->productDiscounts;
  1693.     }
  1695.     public function addProductDiscount(ProductDiscount $productDiscount): static
  1696.     {
  1697.         if (!$this->productDiscounts->contains($productDiscount)) {
  1698.             $this->productDiscounts->add($productDiscount);
  1699.             $productDiscount->setProduct($this);
  1700.         }
  1702.         return $this;
  1703.     }
  1705.     public function removeProductDiscount(ProductDiscount $productDiscount): static
  1706.     {
  1707.         if ($this->productDiscounts->removeElement($productDiscount)) {
  1708.             // set the owning side to null (unless already changed)
  1709.             if ($productDiscount->getProduct() === $this) {
  1710.                 $productDiscount->setProduct(null);
  1711.             }
  1712.         }
  1714.         return $this;
  1715.     }
  1717.     public function getSallePrice(): ?float
  1718.     {
  1719.         return $this->sallePrice;
  1720.     }
  1722.     public function setSallePrice(?float $sallePrice): static
  1723.     {
  1724.         $this->sallePrice = $sallePrice;
  1726.         return $this;
  1727.     }
  1729.     public function getNormalPrice(): ?float
  1730.     {
  1731.         return $this->normalPrice;
  1732.     }
  1734.     public function setNormalPrice(?float $normalPrice): static
  1735.     {
  1736.         $this->normalPrice = $normalPrice;
  1738.         return $this;
  1739.     }
  1740. }