src/Entity/Product/Product.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Product;
  5. use App\Entity\Components\HardComponent;
  6. use App\Entity\Gallery\Gallery;
  7. use App\Entity\Order\SaleItem;
  8. use App\Repository\Product\ProductRepository;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\DBAL\Types\Types;
  12. use Doctrine\ORM\Mapping as ORM;
  14. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  15. class Product
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $name = null;
  25.     #[ORM\Column]
  26.     private ?bool $is_activ = null;
  28.     #[ORM\Column(type: Types::TEXT)]
  29.     private ?string $content = null;
  31.     #[ORM\Column(length: 255)]
  32.     private ?string $slug = null;
  34.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  35.     private ?\DateTimeInterface $created_at = null;
  37.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  38.     private ?\DateTimeInterface $updated_at = null;
  40.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  41.     private ?\DateTimeInterface $published_at = null;
  43.     #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2)]
  44.     private ?string $price = null;
  46.     #[ORM\Column(length: 355, nullable: true)]
  47.     private ?string $preview = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $reference = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $collection = null;
  55.     #[ORM\Column(length: 355, nullable: true)]
  56.     private ?string $metaDescription = null;
  58.     #[ORM\Column(length: 255, nullable: true)]
  59.     private ?string $pdfName = null;
  61.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  62.     private ?string $draft = null;
  64.     #[ORM\ManyToOne(inversedBy: 'product')]
  65.     private ?Brand $brand = null;
  67.     #[ORM\Column(length: 30, nullable: true)]
  68.     private ?string $skeleton = null;
  70.     #[ORM\ManyToOne]
  71.     private ?HardComponent $hardComponent = null;
  73.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductVariant::class, cascade: ['persist', 'remove'])]
  74.     private Collection $productVariants;
  76.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductAttributeValue::class)]
  77.     private Collection $productAttributeValues;
  79.     #[ORM\ManyToMany(targetEntity: ProductCategory::class, inversedBy: 'products')]
  80.     private Collection $categories;
  82.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductImage::class)]
  83.     private Collection $productImages;
  85.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductTag::class)]
  86.     private Collection $productTags;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?int $stock_quantity = null;
  91.     #[ORM\Column(type: Types::DECIMAL, precision: 3, scale: 2, nullable: true)]
  92.     private ?string $globalNote = null;
  94.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: CustomerComment::class)]
  95.     private Collection $customerComments;
  97.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: CustomerNoteProduct::class, cascade: ['persist', 'remove'])]
  98.     private Collection $customerNotes;
  100.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: SimilarProduct::class, cascade: ['persist', 'remove'])]
  101.     private Collection $similarProducts;
  103.     #[ORM\OneToMany(mappedBy: 'similar', targetEntity: SimilarProduct::class, cascade: ['persist', 'remove'])]
  104.     private Collection $similarToProducts;
  106.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductBoughtTogether::class)]
  107.     private Collection $productBoughtTogethers;
  109.     #[ORM\OneToOne(mappedBy: 'product', cascade: ['persist', 'remove'])]
  110.     private ?SaleItem $saleItem = null;
  112.     #[ORM\Column(length: 50, nullable: true)]
  113.     private ?string $promotion = null;
  115.     public function __construct()
  116.     {
  117.         $this->productVariants = new ArrayCollection();
  118.         $this->productAttributeValues = new ArrayCollection();
  119.         $this->categories = new ArrayCollection();
  120.         $this->productImages = new ArrayCollection();
  121.         $this->productTags = new ArrayCollection();
  122.         $this->customerComments = new ArrayCollection();
  123.         $this->customerNotes = new ArrayCollection();
  124.         $this->similarProducts = new ArrayCollection();
  125.         $this->similarToProducts = new ArrayCollection();
  126.         $this->productBoughtTogethers = new ArrayCollection();
  127.     }
  130.     public function getId(): ?int
  131.     {
  132.         return $this->id;
  133.     }
  135.     public function getName(): ?string
  136.     {
  137.         return $this->name;
  138.     }
  140.     public function setName(string $name): self
  141.     {
  142.         $this->name = $name;
  144.         return $this;
  145.     }
  148.     public function isIsActiv(): ?bool
  149.     {
  150.         return $this->is_activ;
  151.     }
  153.     public function setIsActiv(bool $is_activ): self
  154.     {
  155.         $this->is_activ = $is_activ;
  157.         return $this;
  158.     }
  161.     public function getContent(): ?string
  162.     {
  163.         return $this->content;
  164.     }
  166.     public function setContent(string $content): self
  167.     {
  168.         $this->content = $content;
  170.         return $this;
  171.     }
  173.     public function getSlug(): ?string
  174.     {
  175.         return $this->slug;
  176.     }
  178.     public function setSlug(string $slug): self
  179.     {
  180.         $this->slug = $slug;
  182.         return $this;
  183.     }
  185.     public function getCreatedAt(): ?\DateTimeInterface
  186.     {
  187.         return $this->created_at;
  188.     }
  190.     public function setCreatedAt(?\DateTimeInterface $created_at): self
  191.     {
  192.         $this->created_at = $created_at;
  194.         return $this;
  195.     }
  197.     public function getUpdatedAt(): ?\DateTimeInterface
  198.     {
  199.         return $this->updated_at;
  200.     }
  202.     public function setUpdatedAt(?\DateTimeInterface $updated_at): self
  203.     {
  204.         $this->updated_at = $updated_at;
  206.         return $this;
  207.     }
  209.     public function getPublishedAt(): ?\DateTimeInterface
  210.     {
  211.         return $this->published_at;
  212.     }
  214.     public function setPublishedAt(?\DateTimeInterface $published_at): self
  215.     {
  216.         $this->published_at = $published_at;
  218.         return $this;
  219.     }
  221.     public function getPrice(): ?string
  222.     {
  223.         return $this->price;
  224.     }
  226.     public function setPrice(string $price): self
  227.     {
  228.         $this->price = $price;
  230.         return $this;
  231.     }
  233.     public function getPreview(): ?string
  234.     {
  235.         return $this->preview;
  236.     }
  238.     public function setPreview(?string $preview): self
  239.     {
  240.         $this->preview = $preview;
  242.         return $this;
  243.     }
  245.     public function getReference(): ?string
  246.     {
  247.         return $this->reference;
  248.     }
  250.     public function setReference(?string $reference): self
  251.     {
  252.         $this->reference = $reference;
  254.         return $this;
  255.     }
  257.     public function getCollection(): ?string
  258.     {
  259.         return $this->collection;
  260.     }
  262.     public function setCollection(?string $collection): self
  263.     {
  264.         $this->collection = $collection;
  266.         return $this;
  267.     }
  269.     public function getMetaDescription(): ?string
  270.     {
  271.         return $this->metaDescription;
  272.     }
  274.     public function setMetaDescription(?string $metaDescription): self
  275.     {
  276.         $this->metaDescription = $metaDescription;
  278.         return $this;
  279.     }
  281.     public function getPdfName(): ?string
  282.     {
  283.         return $this->pdfName;
  284.     }
  286.     public function setPdfName(?string $pdfName): self
  287.     {
  288.         $this->pdfName = $pdfName;
  290.         return $this;
  291.     }
  293.     public function getDraft(): ?string
  294.     {
  295.         return $this->draft;
  296.     }
  298.     public function setDraft(?string $draft): self
  299.     {
  300.         $this->draft = $draft;
  302.         return $this;
  303.     }
  305.     public function getBrand(): ?Brand
  306.     {
  307.         return $this->brand;
  308.     }
  310.     public function setBrand(?Brand $brand): self
  311.     {
  312.         $this->brand = $brand;
  314.         return $this;
  315.     }
  317.     public function getSkeleton(): ?string
  318.     {
  319.         return $this->skeleton;
  320.     }
  322.     public function setSkeleton(?string $skeleton): static
  323.     {
  324.         $this->skeleton = $skeleton;
  326.         return $this;
  327.     }
  329.     public function getHardComponent(): ?HardComponent
  330.     {
  331.         return $this->hardComponent;
  332.     }
  334.     public function setHardComponent(?HardComponent $hardComponent): static
  335.     {
  336.         $this->hardComponent = $hardComponent;
  338.         return $this;
  339.     }
  341.     /**
  342.      * @return Collection<int, ProductVariant>
  343.      */
  344.     public function getProductVariants(): Collection
  345.     {
  346.         return $this->productVariants;
  347.     }
  349.     public function addProductVariant(ProductVariant $productVariant): static
  350.     {
  351.         if (!$this->productVariants->contains($productVariant)) {
  352.             $this->productVariants->add($productVariant);
  353.             $productVariant->setProduct($this);
  354.         }
  356.         return $this;
  357.     }
  359.     public function removeProductVariant(ProductVariant $productVariant): static
  360.     {
  361.         if ($this->productVariants->removeElement($productVariant)) {
  362.             // set the owning side to null (unless already changed)
  363.             if ($productVariant->getProduct() === $this) {
  364.                 $productVariant->setProduct(null);
  365.             }
  366.         }
  368.         return $this;
  369.     }
  371.     /**
  372.      * @return Collection<int, ProductAttributeValue>
  373.      */
  374.     public function getProductAttributeValues(): Collection
  375.     {
  376.         return $this->productAttributeValues;
  377.     }
  379.     public function addProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  380.     {
  381.         if (!$this->productAttributeValues->contains($productAttributeValue)) {
  382.             $this->productAttributeValues->add($productAttributeValue);
  383.             $productAttributeValue->setProduct($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeProductAttributeValue(ProductAttributeValue $productAttributeValue): static
  390.     {
  391.         if ($this->productAttributeValues->removeElement($productAttributeValue)) {
  392.             // set the owning side to null (unless already changed)
  393.             if ($productAttributeValue->getProduct() === $this) {
  394.                 $productAttributeValue->setProduct(null);
  395.             }
  396.         }
  398.         return $this;
  399.     }
  401.     /**
  402.      * @return Collection<int, ProductCategory>
  403.      */
  404.     public function getCategories(): Collection
  405.     {
  406.         return $this->categories;
  407.     }
  409.     public function addCategory(ProductCategory $category): static
  410.     {
  411.         if (!$this->categories->contains($category)) {
  412.             $this->categories->add($category);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeCategory(ProductCategory $category): static
  419.     {
  420.         $this->categories->removeElement($category);
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, ProductImage>
  427.      */
  428.     public function getProductImages(): Collection
  429.     {
  430.         return $this->productImages;
  431.     }
  433.     public function addProductImage(ProductImage $productImage): static
  434.     {
  435.         if (!$this->productImages->contains($productImage)) {
  436.             $this->productImages->add($productImage);
  437.             $productImage->setProduct($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeProductImage(ProductImage $productImage): static
  444.     {
  445.         if ($this->productImages->removeElement($productImage)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($productImage->getProduct() === $this) {
  448.                 $productImage->setProduct(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     /**
  456.      * @return Collection<int, ProductTag>
  457.      */
  458.     public function getProductTags(): Collection
  459.     {
  460.         return $this->productTags;
  461.     }
  463.     public function addProductTag(ProductTag $productTag): static
  464.     {
  465.         if (!$this->productTags->contains($productTag)) {
  466.             $this->productTags->add($productTag);
  467.             $productTag->setProduct($this);
  468.         }
  470.         return $this;
  471.     }
  473.     public function removeProductTag(ProductTag $productTag): static
  474.     {
  475.         if ($this->productTags->removeElement($productTag)) {
  476.             // set the owning side to null (unless already changed)
  477.             if ($productTag->getProduct() === $this) {
  478.                 $productTag->setProduct(null);
  479.             }
  480.         }
  482.         return $this;
  483.     }
  485.     public function getStockQuantity(): ?int
  486.     {
  487.         return $this->stock_quantity;
  488.     }
  490.     public function setStockQuantity(?int $stock_quantity): static
  491.     {
  492.         $this->stock_quantity = $stock_quantity;
  494.         return $this;
  495.     }
  497.     public function getGlobalNote(): ?string
  498.     {
  499.         return $this->globalNote;
  500.     }
  502.     public function setGlobalNote(?string $globalNote): static
  503.     {
  504.         $this->globalNote = $globalNote;
  506.         return $this;
  507.     }
  509.     /**
  510.      * @return Collection<int, CustomerComment>
  511.      */
  512.     public function getCustomerComments(): Collection
  513.     {
  514.         return $this->customerComments;
  515.     }
  517.     public function addCustomerComment(CustomerComment $customerComment): static
  518.     {
  519.         if (!$this->customerComments->contains($customerComment)) {
  520.             $this->customerComments->add($customerComment);
  521.             $customerComment->setProduct($this);
  522.         }
  524.         return $this;
  525.     }
  527.     public function removeCustomerComment(CustomerComment $customerComment): static
  528.     {
  529.         if ($this->customerComments->removeElement($customerComment)) {
  530.             // set the owning side to null (unless already changed)
  531.             if ($customerComment->getProduct() === $this) {
  532.                 $customerComment->setProduct(null);
  533.             }
  534.         }
  536.         return $this;
  537.     }
  539.     /**
  540.      * @return Collection<int, CustomerNote>
  541.      */
  542.     public function getCustomerNotes(): Collection
  543.     {
  544.         return $this->customerNotes;
  545.     }
  547.     public function addCustomerNote(CustomerNoteProduct $customerNoteProduct): static
  548.     {
  549.         if (!$this->customerNotes->contains($customerNoteProduct)) {
  550.             $this->customerNotes->add($customerNoteProduct);
  551.             $customerNoteProduct->setProduct($this);
  552.         }
  554.         return $this;
  555.     }
  557.     public function removeCustomerNote(CustomerNoteProduct $customerNoteProduct): static
  558.     {
  559.         if ($this->customerNotes->removeElement($customerNoteProduct)) {
  560.             // set the owning side to null (unless already changed)
  561.             if ($customerNoteProduct->getProduct() === $this) {
  562.                 $customerNoteProduct->setProduct(null);
  563.             }
  564.         }
  566.         return $this;
  567.     }
  569.     /**
  570.      * @return Collection<int, SimilarProduct>
  571.      */
  572.     public function getSimilarProducts(): Collection
  573.     {
  574.         return $this->similarProducts;
  575.     }
  577.     public function addSimilarProduct(SimilarProduct $similarProduct): static
  578.     {
  579.         if (!$this->similarProducts->contains($similarProduct)) {
  580.             $this->similarProducts->add($similarProduct);
  581.             $similarProduct->setProduct($this);
  582.         }
  584.         return $this;
  585.     }
  587.     public function removeSimilarProduct(SimilarProduct $similarProduct): static
  588.     {
  589.         if ($this->similarProducts->removeElement($similarProduct)) {
  590.             // set the owning side to null (unless already changed)
  591.             if ($similarProduct->getProduct() === $this) {
  592.                 $similarProduct->setProduct(null);
  593.             }
  594.         }
  596.         return $this;
  597.     }
  599.     /**
  600.      * @return Collection<int, SimilarProduct>
  601.      */
  602.     public function getSimilarToProducts(): Collection
  603.     {
  604.         return $this->similarToProducts;
  605.     }
  606.     public function addSimilarToProduct(SimilarProduct $similarToProduct): static
  607.     {
  608.         if (!$this->similarToProducts->contains($similarToProduct)) {
  609.             $this->similarToProducts->add($similarToProduct);
  610.             $similarToProduct->setSimilar($this);
  611.         }
  613.         return $this;
  614.     }
  616.     /**
  617.      * @return Collection<int, ProductBoughtTogether>
  618.      */
  619.     public function getProductBoughtTogethers(): Collection
  620.     {
  621.         return $this->productBoughtTogethers;
  622.     }
  624.     public function addProductBoughtTogether(ProductBoughtTogether $productBoughtTogether): static
  625.     {
  626.         if (!$this->productBoughtTogethers->contains($productBoughtTogether)) {
  627.             $this->productBoughtTogethers->add($productBoughtTogether);
  628.             $productBoughtTogether->setProduct($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeProductBoughtTogether(ProductBoughtTogether $productBoughtTogether): static
  635.     {
  636.         if ($this->productBoughtTogethers->removeElement($productBoughtTogether)) {
  637.             // set the owning side to null (unless already changed)
  638.             if ($productBoughtTogether->getProduct() === $this) {
  639.                 $productBoughtTogether->setProduct(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     public function getSaleItem(): ?SaleItem
  647.     {
  648.         return $this->saleItem;
  649.     }
  651.     public function setSaleItem(?SaleItem $saleItem): static
  652.     {
  653.         // unset the owning side of the relation if necessary
  654.         if ($saleItem === null && $this->saleItem !== null) {
  655.             $this->saleItem->setProduct(null);
  656.         }
  658.         // set the owning side of the relation if necessary
  659.         if ($saleItem !== null && $saleItem->getProduct() !== $this) {
  660.             $saleItem->setProduct($this);
  661.         }
  663.         $this->saleItem = $saleItem;
  665.         return $this;
  666.     }
  668.     public function getPromotion(): ?string
  669.     {
  670.         return $this->promotion;
  671.     }
  673.     public function setPromotion(?string $promotion): static
  674.     {
  675.         $this->promotion = $promotion;
  677.         return $this;
  678.     }
  679. }