src/Entity/Shop/Product/Product.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Shop\Product;
  5. use App\Entity\BaseEntity;
  6. use App\Entity\Shop\Cart\CartItem;
  7. use App\Entity\Shop\Order\Discount;
  8. use App\Entity\Shop\Order\OrderItem;
  9. use App\Entity\Shop\Shop\Review;
  10. use App\Entity\Shop\Shop\Shop;
  11. use App\Repository\Shop\Product\ProductRepository;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  18. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  19. class Product extends BaseEntity
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\Column(type: 'guid', unique: true)]
  23.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  24.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  25.     private ?string $id;
  27.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  28.     private ?string $stock = null;
  29.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductPrice::class, cascade: ['persist'], orphanRemoval: true)]
  30.     private Collection $productPrices;
  32.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductAttribute::class, cascade: ['persist'], orphanRemoval: true)]
  33.     private Collection $productAttributes;
  35.     #[ORM\Column(length: 255)]
  36.     private ?string $name = null;
  38.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  39.     private ?string $description = null;
  41.     #[ORM\Column(type: Types::BIGINT)]
  42.     private ?string $price = null;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $imageUrl = null;
  49.     #[ORM\ManyToOne(inversedBy: 'products')]
  50.     #[ORM\JoinColumn(nullable: false)]
  51.     private ?Shop $shop = null;
  53.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Discount::class)]
  54.     private Collection $discounts;
  57.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductImage::class, cascade: ['persist'], orphanRemoval: true)]
  58.     private Collection $productImages;
  60.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderItem::class)]
  61.     private Collection $orderItems;
  63.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: CartItem::class)]
  64.     private Collection $cartItems;
  66.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Review::class)]
  67.     private Collection $reviews;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $subName = null;
  72.     #[ORM\ManyToMany(targetEntity: ProductCategory::class, mappedBy: 'products', cascade: ['persist'])]
  73.     private Collection $productCategories;
  75.     #[ORM\ManyToMany(targetEntity: ProductTag::class, mappedBy: 'products', cascade: ['persist'])]
  76.     private Collection $productTags;
  78.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductReview::class)]
  79.     private Collection $productReviews;
  81.     #[ORM\Column(nullable: true)]
  82.     private ?bool $isSelling = null;
  85.     public function __construct()
  86.     {
  87.         parent::__construct();
  88.         $this->setPrice(0);
  89.         $this->productAttributes = new ArrayCollection();
  90.         $this->discounts = new ArrayCollection();
  91.         $this->productImages = new ArrayCollection();
  92.         $this->orderItems = new ArrayCollection();
  93.         $this->cartItems = new ArrayCollection();
  94.         $this->reviews = new ArrayCollection();
  95.         $this->productPrices = new ArrayCollection();
  96.         $this->productCategories = new ArrayCollection();
  97.         $this->productTags = new ArrayCollection();
  98.         $this->productReviews = new ArrayCollection();
  99.     }
  101.     public function __toString()
  102.     {
  103.         return $this->getName();
  104.     }
  106.     public function getMinPrice(): ?int
  107.     {
  108.         if (!$this->isVariablePriced()) {
  109.             return $this->getPrice(); // قیمت ساده
  110.         }
  112.         $prices = $this->getProductPrices()->map(fn($p) => $p->getPrice())->toArray();
  114.         return !empty($prices) ? min($prices) : null;
  115.     }
  117.     public function isVariablePriced(): bool
  118.     {
  119.         return !$this->productPrices->isEmpty();
  120.     }
  122.     public function getDisplayPrice(): ?int
  123.     {
  124.         return $this->isVariablePriced()
  125.             ? $this->getMinPrice()
  126.             : $this->getPrice();
  127.     }
  129.     public function getId(): ?string
  130.     {
  131.         return $this->id;
  132.     }
  134.     /**
  135.      * @return Collection<int, ProductAttribute>
  136.      */
  137.     public function getProductAttributes(): Collection
  138.     {
  139.         return $this->productAttributes;
  140.     }
  142.     public function addProductAttribute(ProductAttribute $productAttribute): static
  143.     {
  144.         if (!$this->productAttributes->contains($productAttribute)) {
  145.             $this->productAttributes->add($productAttribute);
  146.             $productAttribute->setProduct($this);
  147.         }
  149.         return $this;
  150.     }
  152.     public function removeProductAttribute(ProductAttribute $productAttribute): static
  153.     {
  154.         if ($this->productAttributes->removeElement($productAttribute)) {
  155.             // set the owning side to null (unless already changed)
  156.             if ($productAttribute->getProduct() === $this) {
  157.                 $productAttribute->setProduct(null);
  158.             }
  159.         }
  161.         return $this;
  162.     }
  164.     public function getName(): ?string
  165.     {
  166.         return $this->name;
  167.     }
  169.     public function setName(string $name): static
  170.     {
  171.         $this->name = $name;
  173.         return $this;
  174.     }
  176.     public function getDescription(): ?string
  177.     {
  178.         return $this->description;
  179.     }
  181.     public function setDescription(?string $description): static
  182.     {
  183.         $this->description = $description;
  185.         return $this;
  186.     }
  188.     public function getPrice(): ?string
  189.     {
  190.         return $this->price;
  191.     }
  193.     public function setPrice(string $price): static
  194.     {
  195.         $this->price = $price;
  197.         return $this;
  198.     }
  200.     public function getStock(): ?string
  201.     {
  202.         return $this->stock;
  203.     }
  205.     public function setStock(string $stock): static
  206.     {
  207.         $this->stock = $stock;
  209.         return $this;
  210.     }
  212.     public function getImageUrl(): ?string
  213.     {
  214.         return $this->imageUrl;
  215.     }
  217.     public function setImageUrl(?string $imageUrl): static
  218.     {
  219.         $this->imageUrl = $imageUrl;
  221.         return $this;
  222.     }
  224.     public function getShop(): ?Shop
  225.     {
  226.         return $this->shop;
  227.     }
  229.     public function setShop(?Shop $shop): static
  230.     {
  231.         $this->shop = $shop;
  233.         return $this;
  234.     }
  236.     /**
  237.      * @return Collection<int, Discount>
  238.      */
  239.     public function getDiscounts(): Collection
  240.     {
  241.         return $this->discounts;
  242.     }
  244.     public function addDiscount(Discount $discount): static
  245.     {
  246.         if (!$this->discounts->contains($discount)) {
  247.             $this->discounts->add($discount);
  248.             $discount->setProduct($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeDiscount(Discount $discount): static
  255.     {
  256.         if ($this->discounts->removeElement($discount)) {
  257.             // set the owning side to null (unless already changed)
  258.             if ($discount->getProduct() === $this) {
  259.                 $discount->setProduct(null);
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     public function getCategory()
  267.     {
  268.         return $this->productCategories->first();
  269.     }
  271.     public function setCategory(?ProductCategory $category): static
  272.     {
  273.         $this->category = $category;
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection<int, ProductImage>
  280.      */
  281.     public function getProductImages(): Collection
  282.     {
  283.         return $this->productImages;
  284.     }
  286.     public function addProductImage(ProductImage $productImage): static
  287.     {
  288.         if (!$this->productImages->contains($productImage)) {
  289.             $this->productImages->add($productImage);
  290.             $productImage->setProduct($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeProductImage(ProductImage $productImage): static
  297.     {
  298.         if ($this->productImages->removeElement($productImage)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($productImage->getProduct() === $this) {
  301.                 $productImage->setProduct(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     /**
  309.      * @return Collection<int, OrderItem>
  310.      */
  311.     public function getOrderItems(): Collection
  312.     {
  313.         return $this->orderItems;
  314.     }
  316.     public function addOrderItem(OrderItem $orderItem): static
  317.     {
  318.         if (!$this->orderItems->contains($orderItem)) {
  319.             $this->orderItems->add($orderItem);
  320.             $orderItem->setProduct($this);
  321.         }
  323.         return $this;
  324.     }
  326.     public function removeOrderItem(OrderItem $orderItem): static
  327.     {
  328.         if ($this->orderItems->removeElement($orderItem)) {
  329.             // set the owning side to null (unless already changed)
  330.             if ($orderItem->getProduct() === $this) {
  331.                 $orderItem->setProduct(null);
  332.             }
  333.         }
  335.         return $this;
  336.     }
  338.     /**
  339.      * @return Collection<int, CartItem>
  340.      */
  341.     public function getCartItems(): Collection
  342.     {
  343.         return $this->cartItems;
  344.     }
  346.     public function addCartItem(CartItem $cartItem): static
  347.     {
  348.         if (!$this->cartItems->contains($cartItem)) {
  349.             $this->cartItems->add($cartItem);
  350.             $cartItem->setProduct($this);
  351.         }
  353.         return $this;
  354.     }
  356.     public function removeCartItem(CartItem $cartItem): static
  357.     {
  358.         if ($this->cartItems->removeElement($cartItem)) {
  359.             // set the owning side to null (unless already changed)
  360.             if ($cartItem->getProduct() === $this) {
  361.                 $cartItem->setProduct(null);
  362.             }
  363.         }
  365.         return $this;
  366.     }
  368.     /**
  369.      * @return Collection<int, Review>
  370.      */
  371.     public function getReviews(): Collection
  372.     {
  373.         return $this->reviews;
  374.     }
  376.     public function addReview(Review $review): static
  377.     {
  378.         if (!$this->reviews->contains($review)) {
  379.             $this->reviews->add($review);
  380.             $review->setProduct($this);
  381.         }
  383.         return $this;
  384.     }
  386.     public function removeReview(Review $review): static
  387.     {
  388.         if ($this->reviews->removeElement($review)) {
  389.             // set the owning side to null (unless already changed)
  390.             if ($review->getProduct() === $this) {
  391.                 $review->setProduct(null);
  392.             }
  393.         }
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, ProductPrice>
  400.      */
  401.     public function getProductPrices(): Collection
  402.     {
  403.         return $this->productPrices;
  404.     }
  406.     public function addProductPrice(ProductPrice $productPrice): static
  407.     {
  408.         if (!$this->productPrices->contains($productPrice)) {
  409.             $this->productPrices->add($productPrice);
  410.             $productPrice->setProduct($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeProductPrice(ProductPrice $productPrice): static
  417.     {
  418.         if ($this->productPrices->removeElement($productPrice)) {
  419.             // set the owning side to null (unless already changed)
  420.             if ($productPrice->getProduct() === $this) {
  421.                 $productPrice->setProduct(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     public function getSubName(): ?string
  429.     {
  430.         return $this->subName;
  431.     }
  433.     public function setSubName(?string $subName): static
  434.     {
  435.         $this->subName = $subName;
  437.         return $this;
  438.     }
  440.     /**
  441.      * @return Collection<int, ProductCategory>
  442.      */
  443.     public function getProductCategories(): Collection
  444.     {
  445.         return $this->productCategories;
  446.     }
  448.     public function addProductCategory(ProductCategory $productCategory): static
  449.     {
  450.         if (!$this->productCategories->contains($productCategory)) {
  451.             $this->productCategories->add($productCategory);
  452.             $productCategory->addProduct($this);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeProductCategory(ProductCategory $productCategory): static
  459.     {
  460.         if ($this->productCategories->removeElement($productCategory)) {
  461.             $productCategory->removeProduct($this);
  462.         }
  464.         return $this;
  465.     }
  467.     /**
  468.      * @return Collection<int, ProductTag>
  469.      */
  470.     public function getProductTags(): Collection
  471.     {
  472.         return $this->productTags;
  473.     }
  475.     public function addProductTag(ProductTag $productTag): static
  476.     {
  477.         if (!$this->productTags->contains($productTag)) {
  478.             $this->productTags->add($productTag);
  479.             $productTag->addProduct($this);
  480.         }
  482.         return $this;
  483.     }
  485.     public function removeProductTag(ProductTag $productTag): static
  486.     {
  487.         if ($this->productTags->removeElement($productTag)) {
  488.             $productTag->removeProduct($this);
  489.         }
  491.         return $this;
  492.     }
  494.     /**
  495.      * @return Collection<int, ProductReview>
  496.      */
  497.     public function getProductReviews(): Collection
  498.     {
  499.         return $this->productReviews;
  500.     }
  502.     public function addProductReview(ProductReview $productReview): static
  503.     {
  504.         if (!$this->productReviews->contains($productReview)) {
  505.             $this->productReviews->add($productReview);
  506.             $productReview->setProduct($this);
  507.         }
  509.         return $this;
  510.     }
  512.     public function removeProductReview(ProductReview $productReview): static
  513.     {
  514.         if ($this->productReviews->removeElement($productReview)) {
  515.             // set the owning side to null (unless already changed)
  516.             if ($productReview->getProduct() === $this) {
  517.                 $productReview->setProduct(null);
  518.             }
  519.         }
  521.         return $this;
  522.     }
  524.     public function isIsSelling(): ?bool
  525.     {
  526.         return $this->isSelling;
  527.     }
  529.     public function setIsSelling(?bool $isSelling): static
  530.     {
  531.         $this->isSelling = $isSelling;
  533.         return $this;
  534.     }
  535. }