src/Entity/Product.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProductRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  12. class Product
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\Column(length: 255)]
  20.     private ?string $slug = null;
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $sku = null;
  25.     #[ORM\Column(length: 255, nullable: true)]
  26.     private ?string $barcode = null;
  28.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  29.     private ?string $description = null;
  31.     #[ORM\Column]
  32.     private array $images = [];
  34.     #[ORM\Column(nullable: true)]
  35.     private ?array $videos = null;
  37.     #[ORM\Column(nullable: true)]
  38.     private ?array $documents = null;
  40.     #[ORM\Column]
  41.     private ?float $price = null;
  43.     #[ORM\Column(nullable: true)]
  44.     private ?float $compareAtPrice = null;
  46.     #[ORM\Column]
  47.     private ?int $stock = null;
  49.     #[ORM\Column]
  50.     private ?int $minStockAlert = null;
  52.     #[ORM\Column]
  53.     private ?bool $manageStock = null;
  55.     #[ORM\Column]
  56.     private ?bool $allowBackorders = null;
  58.     #[ORM\Column(length: 20)]
  59.     private ?string $stockStatus = null;
  61.     #[ORM\Column(nullable: true)]
  62.     private ?float $weight = null;
  64.     #[ORM\Column(nullable: true)]
  65.     private ?float $length = null;
  67.     #[ORM\Column(nullable: true)]
  68.     private ?float $width = null;
  70.     #[ORM\Column(nullable: true)]
  71.     private ?float $height = null;
  73.     #[ORM\Column]
  74.     private ?bool $isDigital = null;
  76.     #[ORM\Column(length: 255, nullable: true)]
  77.     private ?string $digitalFile = null;
  79.     #[ORM\Column(nullable: true)]
  80.     private ?array $attributes = null;
  82.     #[ORM\Column(nullable: true)]
  83.     private ?array $variations = null;
  85.     #[ORM\Column]
  86.     private ?bool $isActive = null;
  88.     #[ORM\Column]
  89.     private ?bool $isFeatured = null;
  91.     #[ORM\Column]
  92.     private ?\DateTimeImmutable $publishedAt = null;
  94.     #[ORM\Column(nullable: true)]
  95.     private ?\DateTimeImmutable $availableFrom = null;
  97.     #[ORM\Column(nullable: true)]
  98.     private ?\DateTimeImmutable $availableTo = null;
  100.     #[ORM\Column(length: 255, nullable: true)]
  101.     private ?string $metaTitle = null;
  103.     #[ORM\Column(length: 255, nullable: true)]
  104.     private ?string $metaDescription = null;
  106.     #[ORM\Column(length: 255, nullable: true)]
  107.     private ?string $metaKeywords = null;
  109.     #[ORM\Column]
  110.     private ?int $viewCount = null;
  112.     #[ORM\Column]
  113.     private ?int $salesCount = null;
  115.     #[ORM\Column]
  116.     private ?float $averageRating = null;
  118.     #[ORM\Column]
  119.     private ?int $reviewCount = null;
  121.     #[ORM\Column(nullable: true)]
  122.     private ?array $tierPrices = null; // [{min:int, price:float}, ...]
  124.     #[ORM\Column(options: ["default" => false])]
  125.     private ?bool $hasTierPricing = false;
  127.     #[ORM\ManyToOne(inversedBy: 'products')]
  128.     #[ORM\JoinColumn(nullable: false)]
  129.     private ?Shop $shop = null;
  131.     #[ORM\ManyToOne(inversedBy: 'products')]
  132.     #[ORM\JoinColumn(nullable: false)]
  133.     private ?Category $category = null;
  135.     #[ORM\ManyToOne(inversedBy: 'products')]
  136.     #[ORM\JoinColumn(nullable: true)]
  137.     private ?Brand $brand = null;
  139.     #[ORM\ManyToOne(inversedBy: 'products')]
  140.     #[ORM\JoinColumn(nullable: true)]
  141.     private ?ProductCondition $condition = null;
  143.     #[ORM\OneToMany(targetEntity: ProductRanking::class, mappedBy: 'product')]
  144.     private Collection $rankings;
  146.     #[ORM\OneToMany(targetEntity: ProductVariant::class, mappedBy: 'product', cascade: ['persist', 'remove'])]
  147.     private Collection $variants;
  149.     #[ORM\OneToMany(targetEntity: ProductDetail::class, mappedBy: 'product', cascade: ['persist', 'remove'])]
  150.     private Collection $details;
  152.     #[ORM\Column(length: 255)]
  153.     private ?string $name = null;
  155.     public function __construct()
  156.     {
  157.         $this->variants = new ArrayCollection();
  158.         $this->details = new ArrayCollection();
  159.     }
  161.     public function getId(): ?int
  162.     {
  163.         return $this->id;
  164.     }
  166.     public function getSlug(): ?string
  167.     {
  168.         return $this->slug;
  169.     }
  171.     public function setSlug(string $slug): static
  172.     {
  173.         $this->slug = $slug;
  175.         return $this;
  176.     }
  178.     public function getSku(): ?string
  179.     {
  180.         return $this->sku;
  181.     }
  183.     public function setSku(string $sku): static
  184.     {
  185.         $this->sku = $sku;
  187.         return $this;
  188.     }
  190.     public function getBarcode(): ?string
  191.     {
  192.         return $this->barcode;
  193.     }
  195.     public function setBarcode(?string $barcode): static
  196.     {
  197.         $this->barcode = $barcode;
  199.         return $this;
  200.     }
  202.     public function getDescription(): ?string
  203.     {
  204.         return $this->description;
  205.     }
  207.     public function setDescription(?string $description): static
  208.     {
  209.         $this->description = $description;
  211.         return $this;
  212.     }
  214.     public function getImages(): array
  215.     {
  216.         return $this->images;
  217.     }
  219.     public function setImages(array $images): static
  220.     {
  221.         $this->images = $images;
  223.         return $this;
  224.     }
  226.     public function getVideos(): ?array
  227.     {
  228.         return $this->videos;
  229.     }
  231.     public function setVideos(?array $videos): static
  232.     {
  233.         $this->videos = $videos;
  235.         return $this;
  236.     }
  238.     public function getDocuments(): ?array
  239.     {
  240.         return $this->documents;
  241.     }
  243.     public function setDocuments(?array $documents): static
  244.     {
  245.         $this->documents = $documents;
  247.         return $this;
  248.     }
  250.     public function getPrice(): ?float
  251.     {
  252.         return $this->price;
  253.     }
  255.     public function setPrice(float $price): static
  256.     {
  257.         $this->price = $price;
  259.         return $this;
  260.     }
  262.     public function getCompareAtPrice(): ?float
  263.     {
  264.         return $this->compareAtPrice;
  265.     }
  267.     public function setCompareAtPrice(?float $compareAtPrice): static
  268.     {
  269.         $this->compareAtPrice = $compareAtPrice;
  271.         return $this;
  272.     }
  274.     public function getStock(): ?int
  275.     {
  276.         return $this->stock;
  277.     }
  279.     public function setStock(int $stock): static
  280.     {
  281.         $this->stock = $stock;
  283.         return $this;
  284.     }
  286.     public function getMinStockAlert(): ?int
  287.     {
  288.         return $this->minStockAlert;
  289.     }
  291.     public function setMinStockAlert(int $minStockAlert): static
  292.     {
  293.         $this->minStockAlert = $minStockAlert;
  295.         return $this;
  296.     }
  298.     public function isManageStock(): ?bool
  299.     {
  300.         return $this->manageStock;
  301.     }
  303.     public function setManageStock(bool $manageStock): static
  304.     {
  305.         $this->manageStock = $manageStock;
  307.         return $this;
  308.     }
  310.     public function isAllowBackorders(): ?bool
  311.     {
  312.         return $this->allowBackorders;
  313.     }
  315.     public function setAllowBackorders(bool $allowBackorders): static
  316.     {
  317.         $this->allowBackorders = $allowBackorders;
  319.         return $this;
  320.     }
  322.     public function getStockStatus(): ?string
  323.     {
  324.         return $this->stockStatus;
  325.     }
  327.     public function setStockStatus(string $stockStatus): static
  328.     {
  329.         $this->stockStatus = $stockStatus;
  331.         return $this;
  332.     }
  334.     public function getWeight(): ?float
  335.     {
  336.         return $this->weight;
  337.     }
  339.     public function setWeight(?float $weight): static
  340.     {
  341.         $this->weight = $weight;
  343.         return $this;
  344.     }
  346.     public function getLength(): ?float
  347.     {
  348.         return $this->length;
  349.     }
  351.     public function setLength(?float $length): static
  352.     {
  353.         $this->length = $length;
  355.         return $this;
  356.     }
  358.     public function getWidth(): ?float
  359.     {
  360.         return $this->width;
  361.     }
  363.     public function setWidth(?float $width): static
  364.     {
  365.         $this->width = $width;
  367.         return $this;
  368.     }
  370.     public function getHeight(): ?float
  371.     {
  372.         return $this->height;
  373.     }
  375.     public function setHeight(?float $height): static
  376.     {
  377.         $this->height = $height;
  379.         return $this;
  380.     }
  382.     public function isIsDigital(): ?bool
  383.     {
  384.         return $this->isDigital;
  385.     }
  387.     public function setIsDigital(bool $isDigital): static
  388.     {
  389.         $this->isDigital = $isDigital;
  391.         return $this;
  392.     }
  394.     public function getDigitalFile(): ?string
  395.     {
  396.         return $this->digitalFile;
  397.     }
  399.     public function setDigitalFile(?string $digitalFile): static
  400.     {
  401.         $this->digitalFile = $digitalFile;
  403.         return $this;
  404.     }
  406.     public function getAttributes(): ?array
  407.     {
  408.         return $this->attributes;
  409.     }
  411.     public function setAttributes(?array $attributes): static
  412.     {
  413.         $this->attributes = $attributes;
  415.         return $this;
  416.     }
  418.     public function getVariations(): ?array
  419.     {
  420.         return $this->variations;
  421.     }
  423.     public function setVariations(?array $variations): static
  424.     {
  425.         $this->variations = $variations;
  427.         return $this;
  428.     }
  430.     public function isIsActive(): ?bool
  431.     {
  432.         return $this->isActive;
  433.     }
  435.     public function setIsActive(bool $isActive): static
  436.     {
  437.         $this->isActive = $isActive;
  439.         return $this;
  440.     }
  442.     public function isIsFeatured(): ?bool
  443.     {
  444.         return $this->isFeatured;
  445.     }
  447.     public function setIsFeatured(bool $isFeatured): static
  448.     {
  449.         $this->isFeatured = $isFeatured;
  451.         return $this;
  452.     }
  454.     public function getPublishedAt(): ?\DateTimeImmutable
  455.     {
  456.         return $this->publishedAt;
  457.     }
  459.     public function setPublishedAt(\DateTimeImmutable $publishedAt): static
  460.     {
  461.         $this->publishedAt = $publishedAt;
  463.         return $this;
  464.     }
  466.     public function getAvailableFrom(): ?\DateTimeImmutable
  467.     {
  468.         return $this->availableFrom;
  469.     }
  471.     public function setAvailableFrom(?\DateTimeImmutable $availableFrom): static
  472.     {
  473.         $this->availableFrom = $availableFrom;
  475.         return $this;
  476.     }
  478.     public function getAvailableTo(): ?\DateTimeImmutable
  479.     {
  480.         return $this->availableTo;
  481.     }
  483.     public function setAvailableTo(?\DateTimeImmutable $availableTo): static
  484.     {
  485.         $this->availableTo = $availableTo;
  487.         return $this;
  488.     }
  490.     public function getMetaTitle(): ?string
  491.     {
  492.         return $this->metaTitle;
  493.     }
  495.     public function setMetaTitle(?string $metaTitle): static
  496.     {
  497.         $this->metaTitle = $metaTitle;
  499.         return $this;
  500.     }
  502.     public function getMetaDescription(): ?string
  503.     {
  504.         return $this->metaDescription;
  505.     }
  507.     public function setMetaDescription(?string $metaDescription): static
  508.     {
  509.         $this->metaDescription = $metaDescription;
  511.         return $this;
  512.     }
  514.     public function getMetaKeywords(): ?string
  515.     {
  516.         return $this->metaKeywords;
  517.     }
  519.     public function setMetaKeywords(?string $metaKeywords): static
  520.     {
  521.         $this->metaKeywords = $metaKeywords;
  523.         return $this;
  524.     }
  526.     public function getViewCount(): ?int
  527.     {
  528.         return $this->viewCount;
  529.     }
  531.     public function setViewCount(int $viewCount): static
  532.     {
  533.         $this->viewCount = $viewCount;
  535.         return $this;
  536.     }
  538.     public function getSalesCount(): ?int
  539.     {
  540.         return $this->salesCount;
  541.     }
  543.     public function setSalesCount(int $salesCount): static
  544.     {
  545.         $this->salesCount = $salesCount;
  547.         return $this;
  548.     }
  550.     public function getAverageRating(): ?float
  551.     {
  552.         return $this->averageRating;
  553.     }
  555.     public function setAverageRating(float $averageRating): static
  556.     {
  557.         $this->averageRating = $averageRating;
  559.         return $this;
  560.     }
  562.     public function getReviewCount(): ?int
  563.     {
  564.         return $this->reviewCount;
  565.     }
  567.     public function setReviewCount(int $reviewCount): static
  568.     {
  569.         $this->reviewCount = $reviewCount;
  571.         return $this;
  572.     }
  574.     public function getTierPrices(): ?array
  575.     {
  576.         return $this->tierPrices;
  577.     }
  579.     public function setTierPrices(?array $tierPrices): static
  580.     {
  581.         $this->tierPrices = $tierPrices;
  582.         return $this;
  583.     }
  585.     public function hasTierPricing(): ?bool
  586.     {
  587.         return $this->hasTierPricing;
  588.     }
  590.     public function setHasTierPricing(bool $hasTierPricing): static
  591.     {
  592.         $this->hasTierPricing = $hasTierPricing;
  593.         return $this;
  594.     }
  596.     public function getShop(): ?Shop
  597.     {
  598.         return $this->shop;
  599.     }
  601.     public function setShop(?Shop $shop): static
  602.     {
  603.         $this->shop = $shop;
  605.         return $this;
  606.     }
  608.     public function getCategory(): ?Category
  609.     {
  610.         return $this->category;
  611.     }
  613.     public function setCategory(?Category $category): static
  614.     {
  615.         $this->category = $category;
  617.         return $this;
  618.     }
  620.     public function getBrand(): ?Brand
  621.     {
  622.         return $this->brand;
  623.     }
  625.     public function setBrand(?Brand $brand): static
  626.     {
  627.         $this->brand = $brand;
  629.         return $this;
  630.     }
  632.     public function getCondition(): ?ProductCondition
  633.     {
  634.         return $this->condition;
  635.     }
  637.     public function setCondition(?ProductCondition $condition): static
  638.     {
  639.         $this->condition = $condition;
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection<int, ProductRanking>
  646.      */
  647.     public function getRankings(): Collection
  648.     {
  649.         return $this->rankings;
  650.     }
  652.     public function addRanking(ProductRanking $ranking): static
  653.     {
  654.         if (!$this->rankings->contains($ranking)) {
  655.             $this->rankings->add($ranking);
  656.             $ranking->setProduct($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeRanking(ProductRanking $ranking): static
  663.     {
  664.         if ($this->rankings->removeElement($ranking)) {
  665.             if ($ranking->getProduct() === $this) {
  666.                 $ranking->setProduct(null);
  667.             }
  668.         }
  670.         return $this;
  671.     }
  673.     /**
  674.      * Obtenir le rang dans une catégorie spécifique
  675.      */
  676.     public function getRankInCategory(Category $category): ?int
  677.     {
  678.         foreach ($this->rankings as $ranking) {
  679.             if ($ranking->getCategory() === $category) {
  680.                 return $ranking->getRank();
  681.             }
  682.         }
  683.         return null;
  684.     }
  686.     /**
  687.      * Obtenir le meilleur rang du produit
  688.      */
  689.     public function getBestRank(): ?int
  690.     {
  691.         $bestRank = null;
  692.         foreach ($this->rankings as $ranking) {
  693.             if ($bestRank === null || $ranking->getRank() < $bestRank) {
  694.                 $bestRank = $ranking->getRank();
  695.             }
  696.         }
  697.         return $bestRank;
  698.     }
  700.     /**
  701.      * @return Collection<int, ProductVariant>
  702.      */
  703.     public function getVariants(): Collection
  704.     {
  705.         return $this->variants;
  706.     }
  708.     public function addVariant(ProductVariant $variant): static
  709.     {
  710.         if (!$this->variants->contains($variant)) {
  711.             $this->variants->add($variant);
  712.             $variant->setProduct($this);
  713.         }
  715.         return $this;
  716.     }
  718.     public function removeVariant(ProductVariant $variant): static
  719.     {
  720.         if ($this->variants->removeElement($variant)) {
  721.             if ($variant->getProduct() === $this) {
  722.                 $variant->setProduct(null);
  723.             }
  724.         }
  726.         return $this;
  727.     }
  729.     /**
  730.      * Obtenir la variante par défaut
  731.      */
  732.     public function getDefaultVariant(): ?ProductVariant
  733.     {
  734.         foreach ($this->variants as $variant) {
  735.             if ($variant->isIsDefault() && $variant->isIsActive()) {
  736.                 return $variant;
  737.             }
  738.         }
  739.         return $this->variants->first() ?: null;
  740.     }
  742.     /**
  743.      * Vérifier si le produit a des variantes
  744.      */
  745.     public function hasVariants(): bool
  746.     {
  747.         return $this->variants->count() > 0;
  748.     }
  750.     /**
  751.      * @return Collection<int, ProductDetail>
  752.      */
  753.     public function getDetails(): Collection
  754.     {
  755.         return $this->details;
  756.     }
  758.     public function addDetail(ProductDetail $detail): static
  759.     {
  760.         if (!$this->details->contains($detail)) {
  761.             $this->details->add($detail);
  762.             $detail->setProduct($this);
  763.         }
  765.         return $this;
  766.     }
  768.     public function removeDetail(ProductDetail $detail): static
  769.     {
  770.         if ($this->details->removeElement($detail)) {
  771.             if ($detail->getProduct() === $this) {
  772.                 $detail->setProduct(null);
  773.             }
  774.         }
  776.         return $this;
  777.     }
  779.     public function getName(): ?string
  780.     {
  781.         return $this->name;
  782.     }
  784.     public function setName(string $name): static
  785.     {
  786.         $this->name = $name;
  788.         return $this;
  789.     }
  790. }