src/Flexy/ShopBundle/Entity/Product/Product.php line 42

  1. <?php
  3. namespace App\Flexy\ShopBundle\Entity\Product;
  5. use ApiPlatform\Core\Annotation\ApiResource;
  6. use App\Flexy\ShopBundle\Entity\Brand;
  7. use App\Flexy\ShopBundle\Entity\Order\OrderItem;
  8. use App\Flexy\ShopBundle\Entity\Product\CategoryProduct;
  9. use App\Flexy\ShopBundle\Entity\Promotion\Promotion;
  10. use App\Flexy\ShopBundle\Entity\Store\Store;
  11. use App\Flexy\ShopBundle\Entity\Vendor\Vendor;
  12. use App\Flexy\ShopBundle\Repository\Product\ProductRepository;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Doctrine\ORM\Mapping\Table;
  17. use Doctrine\ORM\Mapping\Entity;
  18. use Doctrine\ORM\Mapping\InheritanceType;
  19. use Gedmo\Mapping\Annotation as Gedmo;
  20. use Symfony\Component\Filesystem\Filesystem;
  21. use Symfony\Component\Serializer\Annotation\Groups;
  22. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  23. use ApiPlatform\Core\Annotation\ApiFilter;
  24. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  26. #[ApiResource(
  27.     normalizationContext: ['groups' => ['read']],
  28.     denormalizationContext: ['groups' => ['write']],
  29.     
  30.     )]
  31. #[ApiFilter(SearchFilter::class, properties: ['name' => 'partial','categoriesProduct' => 'partial','productType'=>'exact'])]
  32. #[Table(name: 'product')]
  33. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  35. #[InheritanceType('JOINED')]
  36. #[Gedmo\SoftDeleteable(fieldName: 'deletedAt', timeAware: false, hardDelete: true)]
  37. #[Gedmo\Tree(type: 'nested')]
  38. #[UniqueEntity(
  39.     fields: ['name'],
  40.     message: 'Ce produit avec ce nom est déja existe, utilisez un autre nom pour ce produit.',
  41. )]
  42. class Product implements \Stringable
  43. {
  44.     #[Groups(['read', 'readDeep'])]
  45.     #[ORM\Id]
  46.     #[ORM\GeneratedValue]
  47.     #[ORM\Column(type: 'integer')]
  48.     private $id;
  50.     #[Groups(['read', 'readDeep'])]
  51.     #[ORM\Column(type: 'string', length: 255)]
  52.     private ?string $name = null;
  55.     #[Groups(['read', 'readDeep'])]
  56.     #[ORM\Column(type: 'string', length: 255,nullable:true)]
  57.     private string|null $image = "" ;
  59.     #[Groups(['read', 'readDeep'])]
  60.     #[ORM\Column(type: 'float',nullable:true)]
  61.     private ?float $price = 0;
  63.     #[Groups(['read', 'readDeep'])]
  64.     #[ORM\Column(type: 'text', nullable: true)]
  65.     private ?string $description = null;
  67.     #[ORM\ManyToMany(targetEntity: CategoryProduct::class, inversedBy: 'products', cascade: ['persist'])]
  68.     private  $categoriesProduct;
  70.     #[ORM\OneToMany(targetEntity: AttributValue::class, mappedBy: 'product', cascade: ['persist'])]
  71.     #[Groups(['read', 'readDeep'])]
  72.     private  $attributValues;
  74.     #[Groups(['read', 'readDeep'])]
  75.     #[ORM\Column(type: 'float', nullable: true)]
  76.     private ?float $oldPrice = null;
  78.     #[Groups(['read', 'readDeep'])]
  79.     #[ORM\Column(type: 'integer', nullable: true)]
  80.     private ?int $quantity = null;
  82.     #[Groups(['read', 'readDeep'])]
  83.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  84.     private ?string $productType = "simple";
  86.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  87.     private ?string $metaTitle = null;
  89.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  90.     private ?string $metaDescription = null;
  92.     #[ORM\Column(type: 'simple_array', nullable: true)]
  93.     private ?array $metaKeywords = [];
  95.     #[ORM\OneToMany(targetEntity: ImageProduct::class, mappedBy: 'product', cascade: ['persist'])]
  96.     private  $images;
  98.     /**
  99.      * @Gedmo\Slug(fields={"name"})
  100.      */
  101.     #[ORM\Column(type: 'string', length: 255)]
  102.     private ?string $slug = null;
  104.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  105.     private ?\DateTimeImmutable $createdAt = null;
  107.     #[ORM\OneToMany(targetEntity: ProductVariant::class, mappedBy: 'product', cascade: ['persist'])]
  108.     private  $productVariants;
  110.     #[ORM\Column(type: 'boolean', nullable: true)]
  111.     private ?bool $isPriceReducedPerPercent = null;
  113.     #[ORM\Column(type: 'float', nullable: true)]
  114.     private ?float $percentReduction = null;
  116.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  117.     private ?string $skuCode = null;
  119.     #[ORM\OneToMany(targetEntity: OrderItem::class, mappedBy: 'product', cascade: ['persist'])]
  120.     private  $orderItems;
  122.     #[ORM\ManyToOne(targetEntity: Promotion::class, inversedBy: 'products')]
  123.     private ?\App\Flexy\ShopBundle\Entity\Promotion\Promotion $promotion = null;
  125.     #[ORM\ManyToOne(targetEntity: Vendor::class, inversedBy: 'products')]
  126.     private ?\App\Flexy\ShopBundle\Entity\Vendor\Vendor $vendor = null;
  128.     #[ORM\ManyToOne(targetEntity: Brand::class, inversedBy: 'products', cascade: ['persist'])]
  129.     private ?\App\Flexy\ShopBundle\Entity\Brand $brand = null;
  131.     #[ORM\Column(type: 'text', nullable: true)]
  132.     private ?string $shortDescription = null;
  134.     #[ORM\Column(type: 'boolean', nullable: true)]
  135.     private ?bool $isPublished = true;
  137.     #[ORM\OneToMany(targetEntity: Comment::class, mappedBy: 'product')]
  138.     private  $comments;
  140.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  141.     private ?string $skuCodeShop = null;
  143.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  144.     private ?\DateTimeImmutable $endAt = null;
  146.     #[ORM\ManyToOne(targetEntity: CategoryProduct::class, inversedBy: 'productsChildrens')]
  147.     private ?\App\Flexy\ShopBundle\Entity\Product\CategoryProduct $parentCategory = null;
  149.     #[ORM\ManyToOne(targetEntity: Product::class)]
  150.     private ?\App\Flexy\ShopBundle\Entity\Product\Product $clonedProduct = null;
  152.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  153.     private ?string $typeReduction = null;
  155.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  156.     private ?string $valueReduction = null;
  158.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductSubscription::class, orphanRemoval: true)]
  159.     private Collection $productSubscriptions;
  161.     #[ORM\Column(nullable: true)]
  162.     #[Groups(['read', 'readDeep'])]
  163.     private ?float $subscriptionMonthlyPrice = null;
  165.     #[ORM\Column(nullable: true)]
  166.     #[Groups(['read', 'readDeep'])]
  167.     private ?float $subscriptionYearlyPrice = null;
  169.     #[ORM\ManyToOne(inversedBy: 'products')]
  170.     private ?Store $store = null;
  173.     #[ORM\Column(nullable: true)]
  174.     private ?\DateTimeImmutable $deletedAt = null;
  178.     #[ORM\OneToMany(mappedBy: 'parentProduct', targetEntity: ProductPack::class, orphanRemoval: true,cascade:["persist","remove"])]
  179.     private Collection $childrenProductsPack;
  181.     #[ORM\Column(nullable: true)]
  182.     #[Groups(['read', 'readDeep'])]
  183.     private ?bool $labelPriceFrom = null;
  185.     #[ORM\Column(length: 255, nullable: true)]
  186.     private ?string $capacity = null;
  192.     
  195.     public function __construct()
  196.     {
  197.         $this->categoriesProduct = new ArrayCollection();
  198.         $this->attributValues = new ArrayCollection();
  199.         $this->createdAt = new \DateTimeImmutable();
  200.         $this->images = new ArrayCollection();
  201.         $this->productVariants = new ArrayCollection();
  202.         $this->orderItems = new ArrayCollection();
  203.         $this->comments = new ArrayCollection();
  204.         $this->productSubscriptions = new ArrayCollection();
  205.         $this->childrenProductsPack = new ArrayCollection();
  206.        
  208.   
  209.     }
  210.     public function __toString(): string
  211.     {
  212.         return (string) $this->name;
  213.     }
  215.     public function getId(): ?int
  216.     {
  217.         return $this->id;
  218.     }
  220.     #[Groups(['read', 'readDeep'])]
  221.     public function getCategoriesByName(){
  223.         $categories = [];
  225.         foreach($this->categoriesProduct as $singleCategory){
  226.             $categories[]=$singleCategory->getName();
  227.         }
  229.         return $categories;
  230.     }
  233.     #[Groups(['read'])]
  234.     public function getParentCategoryByName(){
  236.         $name = null;
  237.         if($this->parentCategory){
  238.             $name = $this->parentCategory->getName();
  239.         }
  241.         return $name;
  242.     }
  245.     public function setId($id=null): self
  246.     {
  247.         $this->id = $id;
  249.         return $this;
  250.     }
  252.     public function getName(): ?string
  253.     {
  254.         return $this->name;
  255.     }
  257.     public function setName(string $name): self
  258.     {
  259.         $this->name = $name;
  261.         return $this;
  262.     }
  265.     public function getPrice(): ?float
  266.     {
  267.         return $this->price;
  268.     }
  270.     #[Groups(['read', 'readDeep'])]
  271.     public function getReduction(): ?float
  272.     {
  274.         $reduction = 0;
  276.         if($this->typeReduction and $this->valueReduction){
  277.             if($this->typeReduction == "percent"){
  278.                 $reduction = ((float)$this->price  / 100) * $this->valueReduction;
  279.             }else{
  280.                 $reduction =  $this->valueReduction ;
  281.             }
  282.         }
  283.         return $reduction;
  284.     }
  286.     
  288.     public function setPrice(float $price): self
  289.     {
  290.         $this->price = $price;
  292.         return $this;
  293.     }
  295.     public function getDescription(): ?string
  296.     {
  297.         return $this->description;
  298.     }
  300.     public function setDescription(?string $description): self
  301.     {
  302.         $this->description = $description;
  304.         return $this;
  305.     }
  307.     /**
  308.      * Get the value of image
  309.      */ 
  310.     public function getImage()
  311.     {
  312.         return $this->image;
  313.     }
  315.     /**
  316.      * Set the value of image
  317.      */
  318.     public function setImage($image)
  319.     {
  320.         $this->image = (string)$image;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection|CategoryProduct[]
  327.      */
  328.     public function getCategoriesProduct(): Collection
  329.     {
  330.         return $this->categoriesProduct;
  331.     }
  333.     public function addCategoryProduct(CategoryProduct $categoryProduct): self
  334.     {
  335.         if (!$this->categoriesProduct->contains($categoryProduct)) {
  336.             $this->categoriesProduct[] = $categoryProduct;
  337.             $categoryProduct->addProduct($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeCategoryProduct(CategoryProduct $categoryProduct): self
  344.     {
  345.         if ($this->categoriesProduct->removeElement($categoryProduct)) {
  346.             $categoryProduct->removeProduct($this);
  347.         }
  349.         return $this;
  350.     }
  352.     /**
  353.      * @return Collection|AttributValue[]
  354.      */
  355.     public function getAttributValues(): Collection
  356.     {
  357.         return $this->attributValues;
  358.     }
  360.     public function addAttributValue(AttributValue $attributValue): self
  361.     {
  362.         if (!$this->attributValues->contains($attributValue)) {
  363.             $this->attributValues[] = $attributValue;
  364.             $attributValue->setProduct($this);
  365.         }
  367.         return $this;
  368.     }
  370.     public function removeAttributValue(AttributValue $attributValue): self
  371.     {
  372.         if ($this->attributValues->removeElement($attributValue)) {
  373.             // set the owning side to null (unless already changed)
  374.             if ($attributValue->getProduct() === $this) {
  375.                 $attributValue->setProduct(null);
  376.             }
  377.         }
  379.         return $this;
  380.     }
  382.     public function getOldPrice(): ?float
  383.     {
  384.         return $this->oldPrice;
  385.     }
  387.     public function setOldPrice(?float $oldPrice): self
  388.     {
  389.         $this->oldPrice = $oldPrice;
  391.         return $this;
  392.     }
  394.     public function getQuantity(): ?int
  395.     {
  396.         return $this->quantity;
  397.     }
  399.     public function setQuantity(?int $quantity): self
  400.     {
  401.         $this->quantity = $quantity;
  403.         return $this;
  404.     }
  406.     public function getProductType(): ?string
  407.     {
  408.         return $this->productType;
  409.     }
  411.     public function setProductType(?string $productType): self
  412.     {
  413.         $this->productType = $productType;
  415.         return $this;
  416.     }
  418.     public function getMetaTitle(): ?string
  419.     {
  420.         return $this->metaTitle;
  421.     }
  423.     public function setMetaTitle(?string $metaTitle): self
  424.     {
  425.         $this->metaTitle = $metaTitle;
  427.         return $this;
  428.     }
  430.     public function getMetaDescription(): ?string
  431.     {
  432.         return $this->metaDescription;
  433.     }
  435.     public function setMetaDescription(?string $metaDescription): self
  436.     {
  437.         $this->metaDescription = $metaDescription;
  439.         return $this;
  440.     }
  442.     public function getMetaKeywords(): ?array
  443.     {
  444.         return $this->metaKeywords;
  445.     }
  447.     public function setMetaKeywords(?array $metaKeywords): self
  448.     {
  449.         $this->metaKeywords = $metaKeywords;
  451.         return $this;
  452.     }
  454.     /**
  455.      * @return Collection|ImageProduct[]
  456.      */
  457.     public function getImages(): Collection
  458.     {
  459.         return $this->images;
  460.     }
  462.     public function addImage(ImageProduct $image): self
  463.     {
  464.         if (!$this->images->contains($image)) {
  465.             $this->images[] = $image;
  466.             $image->setProduct($this);
  467.         }
  469.         return $this;
  470.     }
  472.     public function removeImage(ImageProduct $image): self
  473.     {
  474.         if ($this->images->removeElement($image)) {
  475.             // set the owning side to null (unless already changed)
  476.             if ($image->getProduct() === $this) {
  477.                 $image->setProduct(null);
  478.             }
  479.         }
  481.         return $this;
  482.     }
  484.     public function getSlug(): ?string
  485.     {
  486.         return $this->slug;
  487.     }
  489.     public function setSlug(string $slug): self
  490.     {
  491.         $this->slug = $slug;
  493.         return $this;
  494.     }
  496.     public function getCreatedAt(): ?\DateTimeImmutable
  497.     {
  498.         return $this->createdAt;
  499.     }
  501.     public function setCreatedAt(?\DateTimeImmutable $createdAt): self
  502.     {
  503.         $this->createdAt = $createdAt;
  505.         return $this;
  506.     }
  508.     /**
  509.      * @return Collection|ProductVariant[]
  510.      */
  511.     public function getProductVariants(): Collection
  512.     {
  513.         return $this->productVariants;
  514.     }
  516.     public function addProductVariant(ProductVariant $productVariant): self
  517.     {
  518.         if (!$this->productVariants->contains($productVariant)) {
  519.             $this->productVariants[] = $productVariant;
  520.             $productVariant->setProduct($this);
  521.         }
  523.         return $this;
  524.     }
  526.     public function removeProductVariant(ProductVariant $productVariant): self
  527.     {
  528.         if ($this->productVariants->removeElement($productVariant)) {
  529.             // set the owning side to null (unless already changed)
  530.             if ($productVariant->getProduct() === $this) {
  531.                 $productVariant->setProduct(null);
  532.             }
  533.         }
  535.         return $this;
  536.     }
  538.     public function getIsPriceReducedPerPercent(): ?bool
  539.     {
  540.         return $this->isPriceReducedPerPercent;
  541.     }
  543.     public function setIsPriceReducedPerPercent(?bool $isPriceReducedPerPercent): self
  544.     {
  545.         $this->isPriceReducedPerPercent = $isPriceReducedPerPercent;
  547.         return $this;
  548.     }
  550.     public function getPercentReduction(): ?float
  551.     {
  552.         return $this->percentReduction;
  553.     }
  555.     public function setPercentReduction(?float $percentReduction): self
  556.     {
  557.         $this->percentReduction = $percentReduction;
  559.         return $this;
  560.     }
  562.     public function getSkuCode(): ?string
  563.     {
  564.         return $this->skuCode;
  565.     }
  567.     public function setSkuCode(?string $skuCode): self
  568.     {
  569.         $this->skuCode = $skuCode;
  571.         return $this;
  572.     }
  574.     /**
  575.      * @return Collection|OrderItem[]
  576.      */
  577.     public function getOrderItems(): Collection
  578.     {
  579.         return $this->orderItems;
  580.     }
  582.     public function addOrderItem(OrderItem $orderItem): self
  583.     {
  584.         if (!$this->orderItems->contains($orderItem)) {
  585.             $this->orderItems[] = $orderItem;
  586.             $orderItem->setProduct($this);
  587.         }
  589.         return $this;
  590.     }
  592.     public function removeOrderItem(OrderItem $orderItem): self
  593.     {
  594.         if ($this->orderItems->removeElement($orderItem)) {
  595.             // set the owning side to null (unless already changed)
  596.             if ($orderItem->getProduct() === $this) {
  597.                 $orderItem->setProduct(null);
  598.             }
  599.         }
  601.         return $this;
  602.     }
  604.     public function getPromotion(): ?Promotion
  605.     {
  606.         return $this->promotion;
  607.     }
  609.     public function setPromotion(?Promotion $promotion): self
  610.     {
  611.         $this->promotion = $promotion;
  613.         return $this;
  614.     }
  616.     #[Groups(['read', 'readDeep'])]
  617.     public function getFinalPrice(){
  618.        
  619.         return $this->price - $this->getReduction() ;
  620.     }
  622.     public function getVendor(): ?Vendor
  623.     {
  624.         return $this->vendor;
  625.     }
  627.     public function setVendor(?Vendor $vendor): self
  628.     {
  629.         $this->vendor = $vendor;
  631.         return $this;
  632.     }
  634.     public function getBrand(): ?Brand
  635.     {
  636.         return $this->brand;
  637.     }
  639.     public function setBrand(?Brand $brand): self
  640.     {
  641.         $this->brand = $brand;
  643.         return $this;
  644.     }
  646.     public function getShortDescription(): ?string
  647.     {
  648.         return $this->shortDescription;
  649.     }
  651.     public function setShortDescription(?string $shortDescription): self
  652.     {
  653.         $this->shortDescription = $shortDescription;
  655.         return $this;
  656.     }
  658.     public function getIsPublished(): ?bool
  659.     {
  660.         return $this->isPublished;
  661.     }
  663.     public function setIsPublished(?bool $isPublished): self
  664.     {
  665.         $this->isPublished = $isPublished;
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection|Comment[]
  672.      */
  673.     public function getComments(): Collection
  674.     {
  675.         return $this->comments;
  676.     }
  678.     public function addComment(Comment $comment): self
  679.     {
  680.         if (!$this->comments->contains($comment)) {
  681.             $this->comments[] = $comment;
  682.             $comment->setProduct($this);
  683.         }
  685.         return $this;
  686.     }
  688.     public function removeComment(Comment $comment): self
  689.     {
  690.         if ($this->comments->removeElement($comment)) {
  691.             // set the owning side to null (unless already changed)
  692.             if ($comment->getProduct() === $this) {
  693.                 $comment->setProduct(null);
  694.             }
  695.         }
  697.         return $this;
  698.     }
  702.     public function getStars5(){
  703.         //for 5 stars
  704.         $stars5=0;
  705.         foreach($this->comments as $singleComment){
  706.             if($singleComment->getRating() == 5){
  707.                 $stars5 = $stars5 + 1;
  708.             }
  709.             
  710.         }
  711.         return $stars5;
  712.     }
  714.     public function getStars4(){
  715.         //for 4 stars
  716.         $stars4=0;
  717.         foreach($this->comments as $singleComment){
  718.             if($singleComment->getRating() == 4){
  719.                 $stars4 = $stars4 + 1;
  720.             }
  721.             
  722.         }
  723.         return $stars4;
  724.     }
  726.     public function getStars3(){
  727.         //for 3 stars
  728.         $stars3=0;
  729.         foreach($this->comments as $singleComment){
  730.             if($singleComment->getRating() == 3){
  731.                 $stars3 = $stars3 + 1;
  732.             }
  733.             
  734.         }
  735.         return $stars3;
  736.     }
  738.     public function getStars2(){
  739.         //for 2 stars
  740.         $stars2=0;
  741.         foreach($this->comments as $singleComment){
  742.             if($singleComment->getRating() == 2){
  743.                 $stars2 = $stars2 + 1;
  744.             }
  745.             
  746.         }
  747.         return $stars2;
  748.     }
  750.     public function getStars1(){
  751.         //for 5 stars
  752.         $stars1=0;
  753.         foreach($this->comments as $singleComment){
  754.             if($singleComment->getRating() == 1){
  755.                 $stars1 = $stars1 + 1;
  756.             }
  757.             
  758.         }
  759.         return $stars1;
  760.     }
  764.     public function getRating(){
  765.         $topRating = 0;
  766.         $totalRating=0;
  768.         $stars5 = $this->getStars5();
  769.         $stars4 = $this->getStars4();
  770.         $stars3 = $this->getStars3();
  771.         $stars2 = $this->getStars2();
  772.         $stars1 = $this->getStars1();
  776.         $topRating = ($stars1 * 1 ) + ($stars2 * 2 ) + ($stars3 * 3 ) + ($stars4 * 4 )+ ($stars5 * 5 );
  777.         $totalRating = $stars1 + $stars2 +$stars3 + $stars4 + $stars5;
  779.         
  780.         $result = 0;
  781.         if($totalRating > 0){
  782.             $result = $topRating / $totalRating;
  783.         }
  784.         
  788.         return $result;
  790.         
  791.     }
  793.     public function getSkuCodeShop(): ?string
  794.     {
  795.         if(!$this->skuCodeShop){
  796.             return $this->skuCodeShop = "OM".$this->createdAt->format("ymdhs").$this->id;
  797.         }
  798.         return $this->skuCodeShop;
  799.     }
  801.     public function setSkuCodeShop(?string $skuCodeShop): self
  802.     {
  803.         $this->skuCodeShop = $skuCodeShop;
  805.         return $this;
  806.     }
  808.     public function addCategoriesProduct(CategoryProduct $categoriesProduct): self
  809.     {
  810.         if (!$this->categoriesProduct->contains($categoriesProduct)) {
  811.             $this->categoriesProduct[] = $categoriesProduct;
  812.         }
  814.         return $this;
  815.     }
  817.     public function removeCategoriesProduct(CategoryProduct $categoriesProduct): self
  818.     {
  819.         $this->categoriesProduct->removeElement($categoriesProduct);
  821.         return $this;
  822.     }
  824.     public function getEndAt(): ?\DateTimeImmutable
  825.     {
  826.         return $this->endAt;
  827.     }
  829.     public function setEndAt(?\DateTimeImmutable $endAt): self
  830.     {
  831.         $this->endAt = $endAt;
  833.         return $this;
  834.     }
  836.     public function getParentCategory(): ?CategoryProduct
  837.     {
  838.         return $this->parentCategory;
  839.     }
  841.     public function setParentCategory(?CategoryProduct $parentCategory): self
  842.     {
  843.         $this->parentCategory = $parentCategory;
  845.         return $this;
  846.     }
  848.     public function getClonedProduct(): ?self
  849.     {
  850.         return $this->clonedProduct;
  851.     }
  853.     public function setClonedProduct(?self $clonedProduct): self
  854.     {
  855.         $this->clonedProduct = $clonedProduct;
  857.         return $this;
  858.     }
  860.     public function getTypeReduction(): ?string
  861.     {
  862.         return $this->typeReduction;
  863.     }
  865.     public function setTypeReduction(?string $typeReduction): self
  866.     {
  867.         $this->typeReduction = $typeReduction;
  869.         return $this;
  870.     }
  872.     public function getValueReduction(): ?string
  873.     {
  874.         return $this->valueReduction;
  875.     }
  877.     public function setValueReduction(?string $valueReduction): self
  878.     {
  879.         $this->valueReduction = $valueReduction;
  881.         return $this;
  882.     }
  884.     /**
  885.      * @return Collection<int, ProductSubscription>
  886.      */
  887.     public function getProductSubscriptions(): Collection
  888.     {
  889.         return $this->productSubscriptions;
  890.     }
  892.     public function addProductSubscription(ProductSubscription $productSubscription): self
  893.     {
  894.         if (!$this->productSubscriptions->contains($productSubscription)) {
  895.             $this->productSubscriptions->add($productSubscription);
  896.             $productSubscription->setProduct($this);
  897.         }
  899.         return $this;
  900.     }
  902.     public function removeProductSubscription(ProductSubscription $productSubscription): self
  903.     {
  904.         if ($this->productSubscriptions->removeElement($productSubscription)) {
  905.             // set the owning side to null (unless already changed)
  906.             if ($productSubscription->getProduct() === $this) {
  907.                 $productSubscription->setProduct(null);
  908.             }
  909.         }
  911.         return $this;
  912.     }
  914.     public function getSubscriptionMonthlyPrice(): ?float
  915.     {
  916.         return $this->subscriptionMonthlyPrice;
  917.     }
  919.     public function setSubscriptionMonthlyPrice(?float $subscriptionMonthlyPrice): self
  920.     {
  921.         $this->subscriptionMonthlyPrice = $subscriptionMonthlyPrice;
  923.         return $this;
  924.     }
  926.     public function getSubscriptionYearlyPrice(): ?float
  927.     {
  928.         return $this->subscriptionYearlyPrice;
  929.     }
  931.     public function setSubscriptionYearlyPrice(?float $subscriptionYearlyPrice): self
  932.     {
  933.         $this->subscriptionYearlyPrice = $subscriptionYearlyPrice;
  935.         return $this;
  936.     }
  938.     public function getStore(): ?Store
  939.     {
  940.         return $this->store;
  941.     }
  943.     public function setStore(?Store $store): self
  944.     {
  945.         $this->store = $store;
  947.         return $this;
  948.     }
  952.    
  957.     /**
  958.      * Get the value of deletedAt
  959.      */ 
  960.     public function getDeletedAt()
  961.     {
  962.         return $this->deletedAt;
  963.     }
  965.     /**
  966.      * Set the value of deletedAt
  967.      *
  968.      * @return  self
  969.      */ 
  970.     public function setDeletedAt($deletedAt)
  971.     {
  972.         $this->deletedAt = $deletedAt;
  974.         return $this;
  975.     }
  977.   
  979.     /**
  980.      * @return Collection<int, ProductPack>
  981.      */
  982.     public function getChildrenProductsPack(): Collection
  983.     {
  984.         return $this->childrenProductsPack;
  985.     }
  987.     public function addChildrenProductsPack(ProductPack $childrenPackProduct): self
  988.     {
  989.         if (!$this->childrenProductsPack->contains($childrenPackProduct)) {
  990.             $this->childrenProductsPack->add($childrenPackProduct);
  991.             $childrenPackProduct->setParentProduct($this);
  992.         }
  994.         return $this;
  995.     }
  997.     public function removeChildrenProductsPack(ProductPack $childrenPackProduct): self
  998.     {
  999.         if ($this->childrenProductsPack->removeElement($childrenPackProduct)) {
  1000.             // set the owning side to null (unless already changed)
  1001.             if ($childrenPackProduct->getParentProduct() === $this) {
  1002.                 $childrenPackProduct->setParentProduct(null);
  1003.             }
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     public function isLabelPriceFrom(): ?bool
  1010.     {
  1011.         return $this->labelPriceFrom;
  1012.     }
  1014.     public function setLabelPriceFrom(?bool $labelPriceFrom): self
  1015.     {
  1016.         $this->labelPriceFrom = $labelPriceFrom;
  1018.         return $this;
  1019.     }
  1021.     public function getCapacity(): ?string
  1022.     {
  1023.         return $this->capacity;
  1024.     }
  1026.     public function setCapacity(?string $capacity): static
  1027.     {
  1028.         $this->capacity = $capacity;
  1030.         return $this;
  1031.     }
  1033.    
  1035.   
  1036. }