src/Entity/ProductVariant.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProductVariantRepository;
  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: ProductVariantRepository::class)]
  12. #[ORM\Table(name: 'product_variants')]
  13. class ProductVariant
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\ManyToOne(inversedBy: 'variants')]
  21.     #[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
  22.     private ?Product $product = null;
  24.     #[ORM\Column(length: 255)]
  25.     private ?string $sku = null;
  27.     #[ORM\Column(length: 255, nullable: true)]
  28.     private ?string $barcode = null;
  30.     #[ORM\Column]
  31.     private ?float $price = null;
  33.     #[ORM\Column(nullable: true)]
  34.     private ?float $compareAtPrice = null;
  36.     #[ORM\Column]
  37.     private ?int $stock = 0;
  39.     #[ORM\Column]
  40.     private ?int $minStockAlert = 0;
  42.     #[ORM\Column]
  43.     private ?bool $manageStock = true;
  45.     #[ORM\Column]
  46.     private ?bool $allowBackorders = false;
  48.     #[ORM\Column(length: 20)]
  49.     private ?string $stockStatus = 'in_stock';
  51.     #[ORM\Column(nullable: true)]
  52.     private ?float $weight = null;
  54.     #[ORM\Column(nullable: true)]
  55.     private ?float $length = null;
  57.     #[ORM\Column(nullable: true)]
  58.     private ?float $width = null;
  60.     #[ORM\Column(nullable: true)]
  61.     private ?float $height = null;
  63.     #[ORM\Column]
  64.     private array $images = []; // Images spécifiques à cette variante
  66.     #[ORM\Column]
  67.     private ?bool $isActive = true;
  69.     #[ORM\Column]
  70.     private ?bool $isDefault = false; // Variante par défaut
  72.     #[ORM\Column]
  73.     private ?int $sortOrder = 0;
  75.     #[ORM\Column]
  76.     private ?\DateTimeImmutable $createdAt = null;
  78.     #[ORM\Column]
  79.     private ?\DateTimeImmutable $updatedAt = null;
  81.     #[ORM\ManyToMany(targetEntity: ProductAttributeValue::class, inversedBy: 'variants')]
  82.     #[ORM\JoinTable(name: 'product_variant_attribute_values')]
  83.     private Collection $attributeValues;
  85.     public function __construct()
  86.     {
  87.         $this->attributeValues = new ArrayCollection();
  88.         $this->createdAt = new \DateTimeImmutable();
  89.         $this->updatedAt = new \DateTimeImmutable();
  90.     }
  92.     public function getId(): ?int
  93.     {
  94.         return $this->id;
  95.     }
  97.     public function getProduct(): ?Product
  98.     {
  99.         return $this->product;
  100.     }
  102.     public function setProduct(?Product $product): static
  103.     {
  104.         $this->product = $product;
  105.         return $this;
  106.     }
  108.     public function getSku(): ?string
  109.     {
  110.         return $this->sku;
  111.     }
  113.     public function setSku(string $sku): static
  114.     {
  115.         $this->sku = $sku;
  116.         return $this;
  117.     }
  119.     public function getBarcode(): ?string
  120.     {
  121.         return $this->barcode;
  122.     }
  124.     public function setBarcode(?string $barcode): static
  125.     {
  126.         $this->barcode = $barcode;
  127.         return $this;
  128.     }
  130.     public function getPrice(): ?float
  131.     {
  132.         return $this->price;
  133.     }
  135.     public function setPrice(float $price): static
  136.     {
  137.         $this->price = $price;
  138.         return $this;
  139.     }
  141.     public function getCompareAtPrice(): ?float
  142.     {
  143.         return $this->compareAtPrice;
  144.     }
  146.     public function setCompareAtPrice(?float $compareAtPrice): static
  147.     {
  148.         $this->compareAtPrice = $compareAtPrice;
  149.         return $this;
  150.     }
  152.     public function getStock(): ?int
  153.     {
  154.         return $this->stock;
  155.     }
  157.     public function setStock(int $stock): static
  158.     {
  159.         $this->stock = $stock;
  160.         return $this;
  161.     }
  163.     public function getMinStockAlert(): ?int
  164.     {
  165.         return $this->minStockAlert;
  166.     }
  168.     public function setMinStockAlert(int $minStockAlert): static
  169.     {
  170.         $this->minStockAlert = $minStockAlert;
  171.         return $this;
  172.     }
  174.     public function isManageStock(): ?bool
  175.     {
  176.         return $this->manageStock;
  177.     }
  179.     public function setManageStock(bool $manageStock): static
  180.     {
  181.         $this->manageStock = $manageStock;
  182.         return $this;
  183.     }
  185.     public function isAllowBackorders(): ?bool
  186.     {
  187.         return $this->allowBackorders;
  188.     }
  190.     public function setAllowBackorders(bool $allowBackorders): static
  191.     {
  192.         $this->allowBackorders = $allowBackorders;
  193.         return $this;
  194.     }
  196.     public function getStockStatus(): ?string
  197.     {
  198.         return $this->stockStatus;
  199.     }
  201.     public function setStockStatus(string $stockStatus): static
  202.     {
  203.         $this->stockStatus = $stockStatus;
  204.         return $this;
  205.     }
  207.     public function getWeight(): ?float
  208.     {
  209.         return $this->weight;
  210.     }
  212.     public function setWeight(?float $weight): static
  213.     {
  214.         $this->weight = $weight;
  215.         return $this;
  216.     }
  218.     public function getLength(): ?float
  219.     {
  220.         return $this->length;
  221.     }
  223.     public function setLength(?float $length): static
  224.     {
  225.         $this->length = $length;
  226.         return $this;
  227.     }
  229.     public function getWidth(): ?float
  230.     {
  231.         return $this->width;
  232.     }
  234.     public function setWidth(?float $width): static
  235.     {
  236.         $this->width = $width;
  237.         return $this;
  238.     }
  240.     public function getHeight(): ?float
  241.     {
  242.         return $this->height;
  243.     }
  245.     public function setHeight(?float $height): static
  246.     {
  247.         $this->height = $height;
  248.         return $this;
  249.     }
  251.     public function getImages(): array
  252.     {
  253.         return $this->images;
  254.     }
  256.     public function setImages(array $images): static
  257.     {
  258.         $this->images = $images;
  259.         return $this;
  260.     }
  262.     public function isIsActive(): ?bool
  263.     {
  264.         return $this->isActive;
  265.     }
  267.     public function setIsActive(bool $isActive): static
  268.     {
  269.         $this->isActive = $isActive;
  270.         return $this;
  271.     }
  273.     public function isIsDefault(): ?bool
  274.     {
  275.         return $this->isDefault;
  276.     }
  278.     public function setIsDefault(bool $isDefault): static
  279.     {
  280.         $this->isDefault = $isDefault;
  281.         return $this;
  282.     }
  284.     public function getSortOrder(): ?int
  285.     {
  286.         return $this->sortOrder;
  287.     }
  289.     public function setSortOrder(int $sortOrder): static
  290.     {
  291.         $this->sortOrder = $sortOrder;
  292.         return $this;
  293.     }
  295.     public function getCreatedAt(): ?\DateTimeImmutable
  296.     {
  297.         return $this->createdAt;
  298.     }
  300.     public function setCreatedAt(\DateTimeImmutable $createdAt): static
  301.     {
  302.         $this->createdAt = $createdAt;
  303.         return $this;
  304.     }
  306.     public function getUpdatedAt(): ?\DateTimeImmutable
  307.     {
  308.         return $this->updatedAt;
  309.     }
  311.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): static
  312.     {
  313.         $this->updatedAt = $updatedAt;
  314.         return $this;
  315.     }
  317.     /**
  318.      * @return Collection<int, ProductAttributeValue>
  319.      */
  320.     public function getAttributeValues(): Collection
  321.     {
  322.         return $this->attributeValues;
  323.     }
  325.     public function addAttributeValue(ProductAttributeValue $attributeValue): static
  326.     {
  327.         if (!$this->attributeValues->contains($attributeValue)) {
  328.             $this->attributeValues->add($attributeValue);
  329.         }
  331.         return $this;
  332.     }
  334.     public function removeAttributeValue(ProductAttributeValue $attributeValue): static
  335.     {
  336.         $this->attributeValues->removeElement($attributeValue);
  338.         return $this;
  339.     }
  341.     /**
  342.      * Obtenir une représentation textuelle de la variante (ex: "Rouge - XL")
  343.      */
  344.     public function getDisplayName(): string
  345.     {
  346.         $parts = [];
  347.         foreach ($this->attributeValues as $value) {
  348.             $parts[] = $value->getValue();
  349.         }
  350.         return implode(' - ', $parts);
  351.     }
  353.     /**
  354.      * Vérifier si la variante est en stock
  355.      */
  356.     public function isInStock(): bool
  357.     {
  358.         if (!$this->isActive) {
  359.             return false;
  360.         }
  362.         if ($this->stockStatus === 'out_of_stock') {
  363.             return false;
  364.         }
  366.         if ($this->manageStock && $this->stock <= 0 && !$this->allowBackorders) {
  367.             return false;
  368.         }
  370.         return true;
  371.     }
  372. }