src/Entity/Website/Product/Product.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Website\Product;
  5. use App\Entity\BaseEntity;
  6. use App\Entity\Website\Cart\CartItem;
  7. use App\Entity\Website\Order\Discount;
  8. use App\Entity\Website\Order\OrderItem;
  9. use App\Entity\Website\Website\Review;
  10. use App\Entity\Website\Website\Website;
  11. use App\Entity\SeoFieldsTrait;
  12. use App\Repository\Website\Product\ProductRepository;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  19. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  20. class Product extends BaseEntity
  21. {
  23.     use SeoFieldsTrait;
  24.     #[ORM\Id]
  25.     #[ORM\Column(type: 'guid', unique: true)]
  26.     #[ORM\GeneratedValue(strategy: 'CUSTOM')]
  27.     #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
  28.     private ?string $id;
  30.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  31.     private ?string $stock = null;
  32.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductPrice::class, cascade: ['persist'], orphanRemoval: true)]
  33.     private Collection $productPrices;
  35.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductAttribute::class, cascade: ['persist'], orphanRemoval: true)]
  36.     private Collection $productAttributes;
  38.     #[ORM\Column(length: 255)]
  39.     private ?string $name = null;
  41.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  42.     private ?string $description = null;
  44.     #[ORM\Column(type: Types::BIGINT)]
  45.     private ?string $price = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $imageUrl = null;
  52.     #[ORM\ManyToOne(inversedBy: 'products')]
  53.     #[ORM\JoinColumn(nullable: false)]
  54.     private ?Website $website = null;
  56.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Discount::class)]
  57.     private Collection $discounts;
  60.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductImage::class, cascade: ['persist'], orphanRemoval: true)]
  61.     private Collection $productImages;
  63.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderItem::class)]
  64.     private Collection $orderItems;
  66.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: CartItem::class)]
  67.     private Collection $cartItems;
  69.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Review::class)]
  70.     private Collection $reviews;
  72.     #[ORM\Column(length: 255, nullable: true)]
  73.     private ?string $subName = null;
  75.     #[ORM\ManyToMany(targetEntity: ProductCategory::class, mappedBy: 'products', cascade: ['persist'])]
  76.     private Collection $productCategories;
  78.     #[ORM\ManyToMany(targetEntity: ProductTag::class, mappedBy: 'products', cascade: ['persist'])]
  79.     private Collection $productTags;
  81.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductReview::class)]
  82.     private Collection $productReviews;
  84.     #[ORM\Column(nullable: true)]
  85.     private ?bool $isSelling = null;
  87.     #[ORM\Column(length: 255, nullable: true)]
  88.     private ?string $publishStatus = null;
  90.     #[ORM\Column(length: 255, nullable: true)]
  91.     private ?string $sku = null;
  94.     public function calculatePrice($data)
  95.     {
  96.         var_dump($data);die;
  97.     }
  101.     public function __construct()
  102.     {
  103.         parent::__construct();
  104.         $this->setPrice(0);
  105.         $this->productAttributes = new ArrayCollection();
  106.         $this->discounts = new ArrayCollection();
  107.         $this->productImages = new ArrayCollection();
  108.         $this->orderItems = new ArrayCollection();
  109.         $this->cartItems = new ArrayCollection();
  110.         $this->reviews = new ArrayCollection();
  111.         $this->productPrices = new ArrayCollection();
  112.         $this->productCategories = new ArrayCollection();
  113.         $this->productTags = new ArrayCollection();
  114.         $this->productReviews = new ArrayCollection();
  115.     }
  117.     public function __toString()
  118.     {
  119.         return $this->getName();
  120.     }
  122.     public function getMinPrice(): ?int
  123.     {
  124.         if (!$this->isVariablePriced()) {
  125.             return $this->getPrice(); // قیمت ساده
  126.         }
  128.         $prices = $this->getProductPrices()->map(fn($p) => $p->getPrice())->toArray();
  130.         return !empty($prices) ? min($prices) : null;
  131.     }
  133.     public function isVariablePriced(): bool
  134.     {
  135.         return !$this->productPrices->isEmpty();
  136.     }
  138.     public function getDisplayPrice(): ?int
  139.     {
  140.         return $this->isVariablePriced()
  141.             ? $this->getMinPrice()
  142.             : $this->getPrice();
  143.     }
  145.     public function getId(): ?string
  146.     {
  147.         return $this->id;
  148.     }
  150.     /**
  151.      * @return Collection<int, ProductAttribute>
  152.      */
  153.     public function getProductAttributes(): Collection
  154.     {
  155.         return $this->productAttributes;
  156.     }
  158.     public function addProductAttribute(ProductAttribute $productAttribute): static
  159.     {
  160.         if (!$this->productAttributes->contains($productAttribute)) {
  161.             $this->productAttributes->add($productAttribute);
  162.             $productAttribute->setProduct($this);
  163.         }
  165.         return $this;
  166.     }
  168.     public function removeProductAttribute(ProductAttribute $productAttribute): static
  169.     {
  170.         if ($this->productAttributes->removeElement($productAttribute)) {
  171.             // set the owning side to null (unless already changed)
  172.             if ($productAttribute->getProduct() === $this) {
  173.                 $productAttribute->setProduct(null);
  174.             }
  175.         }
  177.         return $this;
  178.     }
  180.     public function getName(): ?string
  181.     {
  182.         return $this->name;
  183.     }
  185.     public function setName(string $name): static
  186.     {
  187.         $this->name = $name;
  189.         return $this;
  190.     }
  192.     public function getDescription(): ?string
  193.     {
  194.         return $this->description;
  195.     }
  197.     public function setDescription(?string $description): static
  198.     {
  199.         $this->description = $description;
  201.         return $this;
  202.     }
  204.     public function getPrice(): ?string
  205.     {
  206.         return $this->price;
  207.     }
  209.     public function setPrice(string $price): static
  210.     {
  211.         $this->price = $price;
  213.         return $this;
  214.     }
  216.     public function getStock(): ?string
  217.     {
  218.         return $this->stock;
  219.     }
  221.     public function setStock(string $stock): static
  222.     {
  223.         $this->stock = $stock;
  225.         return $this;
  226.     }
  228.     public function getImageUrl(): ?string
  229.     {
  230.         return $this->imageUrl;
  231.     }
  233.     public function setImageUrl(?string $imageUrl): static
  234.     {
  235.         $this->imageUrl = $imageUrl;
  237.         return $this;
  238.     }
  240.     public function getWebsite(): ?Website
  241.     {
  242.         return $this->website;
  243.     }
  245.     public function setWebsite(?Website $shop): static
  246.     {
  247.         $this->website = $shop;
  249.         return $this;
  250.     }
  252.     /**
  253.      * @return Collection<int, Discount>
  254.      */
  255.     public function getDiscounts(): Collection
  256.     {
  257.         return $this->discounts;
  258.     }
  260.     public function addDiscount(Discount $discount): static
  261.     {
  262.         if (!$this->discounts->contains($discount)) {
  263.             $this->discounts->add($discount);
  264.             $discount->setProduct($this);
  265.         }
  267.         return $this;
  268.     }
  270.     public function removeDiscount(Discount $discount): static
  271.     {
  272.         if ($this->discounts->removeElement($discount)) {
  273.             // set the owning side to null (unless already changed)
  274.             if ($discount->getProduct() === $this) {
  275.                 $discount->setProduct(null);
  276.             }
  277.         }
  279.         return $this;
  280.     }
  282.     public function getCategory()
  283.     {
  284.         return $this->productCategories->first();
  285.     }
  287.     public function setCategory(?ProductCategory $category): static
  288.     {
  289.         $this->category = $category;
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection<int, ProductImage>
  296.      */
  297.     public function getProductImages(): Collection
  298.     {
  299.         return $this->productImages;
  300.     }
  302.     public function addProductImage(ProductImage $productImage): static
  303.     {
  304.         if (!$this->productImages->contains($productImage)) {
  305.             $this->productImages->add($productImage);
  306.             $productImage->setProduct($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeProductImage(ProductImage $productImage): static
  313.     {
  314.         if ($this->productImages->removeElement($productImage)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($productImage->getProduct() === $this) {
  317.                 $productImage->setProduct(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     /**
  325.      * @return Collection<int, OrderItem>
  326.      */
  327.     public function getOrderItems(): Collection
  328.     {
  329.         return $this->orderItems;
  330.     }
  332.     public function addOrderItem(OrderItem $orderItem): static
  333.     {
  334.         if (!$this->orderItems->contains($orderItem)) {
  335.             $this->orderItems->add($orderItem);
  336.             $orderItem->setProduct($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function removeOrderItem(OrderItem $orderItem): static
  343.     {
  344.         if ($this->orderItems->removeElement($orderItem)) {
  345.             // set the owning side to null (unless already changed)
  346.             if ($orderItem->getProduct() === $this) {
  347.                 $orderItem->setProduct(null);
  348.             }
  349.         }
  351.         return $this;
  352.     }
  354.     /**
  355.      * @return Collection<int, CartItem>
  356.      */
  357.     public function getCartItems(): Collection
  358.     {
  359.         return $this->cartItems;
  360.     }
  362.     public function addCartItem(CartItem $cartItem): static
  363.     {
  364.         if (!$this->cartItems->contains($cartItem)) {
  365.             $this->cartItems->add($cartItem);
  366.             $cartItem->setProduct($this);
  367.         }
  369.         return $this;
  370.     }
  372.     public function removeCartItem(CartItem $cartItem): static
  373.     {
  374.         if ($this->cartItems->removeElement($cartItem)) {
  375.             // set the owning side to null (unless already changed)
  376.             if ($cartItem->getProduct() === $this) {
  377.                 $cartItem->setProduct(null);
  378.             }
  379.         }
  381.         return $this;
  382.     }
  384.     /**
  385.      * @return Collection<int, Review>
  386.      */
  387.     public function getReviews(): Collection
  388.     {
  389.         return $this->reviews;
  390.     }
  392.     public function addReview(Review $review): static
  393.     {
  394.         if (!$this->reviews->contains($review)) {
  395.             $this->reviews->add($review);
  396.             $review->setProduct($this);
  397.         }
  399.         return $this;
  400.     }
  402.     public function removeReview(Review $review): static
  403.     {
  404.         if ($this->reviews->removeElement($review)) {
  405.             // set the owning side to null (unless already changed)
  406.             if ($review->getProduct() === $this) {
  407.                 $review->setProduct(null);
  408.             }
  409.         }
  411.         return $this;
  412.     }
  414.     /**
  415.      * @return Collection<int, ProductPrice>
  416.      */
  417.     public function getProductPrices(): Collection
  418.     {
  419.         return $this->productPrices;
  420.     }
  422.     public function addProductPrice(ProductPrice $productPrice): static
  423.     {
  424.         if (!$this->productPrices->contains($productPrice)) {
  425.             $this->productPrices->add($productPrice);
  426.             $productPrice->setProduct($this);
  427.         }
  429.         return $this;
  430.     }
  432.     public function removeProductPrice(ProductPrice $productPrice): static
  433.     {
  434.         if ($this->productPrices->removeElement($productPrice)) {
  435.             // set the owning side to null (unless already changed)
  436.             if ($productPrice->getProduct() === $this) {
  437.                 $productPrice->setProduct(null);
  438.             }
  439.         }
  441.         return $this;
  442.     }
  444.     public function getSubName(): ?string
  445.     {
  446.         return $this->subName;
  447.     }
  449.     public function setSubName(?string $subName): static
  450.     {
  451.         $this->subName = $subName;
  453.         return $this;
  454.     }
  456.     /**
  457.      * @return Collection<int, ProductCategory>
  458.      */
  459.     public function getProductCategories(): Collection
  460.     {
  461.         return $this->productCategories;
  462.     }
  464.     public function addProductCategory(ProductCategory $productCategory): static
  465.     {
  466.         if (!$this->productCategories->contains($productCategory)) {
  467.             $this->productCategories->add($productCategory);
  468.             $productCategory->addProduct($this);
  469.         }
  471.         return $this;
  472.     }
  474.     public function removeProductCategory(ProductCategory $productCategory): static
  475.     {
  476.         if ($this->productCategories->removeElement($productCategory)) {
  477.             $productCategory->removeProduct($this);
  478.         }
  480.         return $this;
  481.     }
  483.     /**
  484.      * @return Collection<int, ProductTag>
  485.      */
  486.     public function getProductTags(): Collection
  487.     {
  488.         return $this->productTags;
  489.     }
  491.     public function addProductTag(ProductTag $productTag): static
  492.     {
  493.         if (!$this->productTags->contains($productTag)) {
  494.             $this->productTags->add($productTag);
  495.             $productTag->addProduct($this);
  496.         }
  498.         return $this;
  499.     }
  501.     public function removeProductTag(ProductTag $productTag): static
  502.     {
  503.         if ($this->productTags->removeElement($productTag)) {
  504.             $productTag->removeProduct($this);
  505.         }
  507.         return $this;
  508.     }
  510.     /**
  511.      * @return Collection<int, ProductReview>
  512.      */
  513.     public function getProductReviews(): Collection
  514.     {
  515.         return $this->productReviews;
  516.     }
  518.     public function addProductReview(ProductReview $productReview): static
  519.     {
  520.         if (!$this->productReviews->contains($productReview)) {
  521.             $this->productReviews->add($productReview);
  522.             $productReview->setProduct($this);
  523.         }
  525.         return $this;
  526.     }
  528.     public function removeProductReview(ProductReview $productReview): static
  529.     {
  530.         if ($this->productReviews->removeElement($productReview)) {
  531.             // set the owning side to null (unless already changed)
  532.             if ($productReview->getProduct() === $this) {
  533.                 $productReview->setProduct(null);
  534.             }
  535.         }
  537.         return $this;
  538.     }
  540.     public function isIsSelling(): ?bool
  541.     {
  542.         return $this->isSelling;
  543.     }
  545.     public function setIsSelling(?bool $isSelling): static
  546.     {
  547.         $this->isSelling = $isSelling;
  549.         return $this;
  550.     }
  552.     public function getPublishStatus(): ?string
  553.     {
  554.         return $this->publishStatus;
  555.     }
  557.     public function setPublishStatus(?string $publishStatus): static
  558.     {
  559.         $this->publishStatus = $publishStatus;
  561.         return $this;
  562.     }
  564.     public function getSku(): ?string
  565.     {
  566.         return $this->sku;
  567.     }
  569.     public function setSku(?string $sku): static
  570.     {
  571.         $this->sku = $sku;
  573.         return $this;
  574.     }
  575. }