src/Entity/Product.php line 14

  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;
  10. use Gedmo\Translatable\Translatable;
  11. use Gedmo\Mapping\Annotation as Gedmo;
  13. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  14. class Product implements Translatable
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column]
  19.     private ?int $id = null;
  21.     #[Gedmo\Translatable]
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $name = "";
  25.     #[Gedmo\Translatable]
  26.     #[ORM\Column(length: 500, nullable: true)]
  27.     private ?string $composition = null;
  29.     #[ORM\Column(nullable: true)]
  30.     private ?int $quantity = null;
  32.     #[ORM\Column(nullable: true)]
  33.     private ?float $weight = null;
  35.     #[ORM\Column(length: 255, nullable: true)]
  36.     private ?string $mainImage = null;
  39.     #[ORM\Column]
  40.     private ?float $price = null;
  42.     #[ORM\Column(nullable: true)]
  43.     private ?float $retailPrice = null;
  45.     #[Gedmo\Translatable]
  46.     #[ORM\Column(type: Types::TEXT)]
  47.     private ?string $description = null;
  49.     #[ORM\Column(length: 255)]
  50.     private ?string $ean = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $slug = null;
  55.     // #[ORM\OneToMany(targetEntity: ProductVariant::class, mappedBy: 'product',cascade: ['persist'])]
  56.     // private $variants;
  58.     #[ORM\Column(length: 255,nullable: true)]
  59.     private ?string $collection_name = null;
  62.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
  63.     private Collection $categories;
  65.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Option::class,cascade: ['persist'])]
  66.     private Collection $options;
  69.     #[ORM\Column(nullable: true)]
  70.     private array $images = [];
  72.     #[ORM\Column(nullable: true)]
  73.     private ?float $profitMargin = null;
  75.     #[ORM\Column(nullable: true)]
  76.     private ?float $promotionMargin = null;
  78.     #[ORM\ManyToMany(targetEntity: ProductCollection::class, inversedBy: 'products')]
  79.     private Collection $collections;
  81.     #[ORM\Column(length: 255, nullable: true)]
  82.     private ?string $api_last_updated = null;
  84.     #[ORM\Column(length: 255, nullable: true)]
  85.     private ?string $modelId = null;
  88.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductVariant::class,cascade: ["persist"])]
  89.     private Collection $variants;
  91.     #[ORM\Column(length: 255)]
  92.     private ?string $apiId = null;
  94.     #[ORM\ManyToOne(inversedBy: 'products')]
  95.     private ?Suplier $supplier = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $mediaPath = null;
  100.     #[ORM\ManyToMany(targetEntity: MarketPlace::class, mappedBy: 'products')]
  101.     private Collection $marketPlaces;
  103.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Listing::class)]
  104.     private Collection $listings;
  105.     
  106.     public function __construct()
  107.     {
  108.         $this->options = new ArrayCollection();
  109.         $this->variants = new ArrayCollection();
  110.         $this->categories = new ArrayCollection();
  111.         $this->collections = new ArrayCollection();
  112.         $this->marketPlaces = new ArrayCollection();
  113.         $this->listings = new ArrayCollection();
  114.     }
  116.     public function getId(): ?int
  117.     {
  118.         return $this->id;
  119.     }
  121.     public function getName(): ?string
  122.     {
  123.         return $this->name;
  124.     }
  126.     public function setName(string $name): self
  127.     {
  128.         $this->name = $name;
  130.         return $this;
  131.     }
  134.     public function getComposition(): string
  135.     {
  136.         return $this->composition;
  137.     }
  139.     public function setComposition(?string $composition): self
  140.     {
  141.         $this->composition = $composition;
  143.         return $this;
  144.     }
  146.     public function getQuantity(): ?int
  147.     {
  148.         $quantities = 0;
  149.         foreach ($this->getVariants() as $variant) {
  150.             $quantities += intval($variant->getQuantity());
  151.         }
  152.         return $quantities;
  153.         // return $this->quantity;
  154.     }
  156.     public function getQuantities(): ?string
  157.     {
  158.         $quantities = 0;
  159.         foreach ($this->getVariants() as $variant) {
  160.             $quantities += $variant->getQuantity();
  161.         }
  162.         return $quantities.' in '.count($this->variants).' variants';
  163.     }
  165.     public function setQuantity(?int $quantity): self
  166.     {
  167.         $this->quantity = $quantity;
  169.         return $this;
  170.     }
  172.     public function getWeight(): ?float
  173.     {
  174.         return $this->weight;
  175.     }
  177.     public function getMaxWeight(): ?float
  178.     {
  179.         $maxWeights = [];
  180.         $maxWeights[] = $this->getWeight();
  181.         foreach ($this->getVariants() as $variant) {
  182.                 $maxWeights[] = $variant->getWeight();
  183.         }
  184.         return max($maxWeights);
  185.     }
  187.     public function getMinWeight(): ?float 
  188.     {
  189.         $minWeights = [];
  190.         $maxWeights[] = $this->getWeight();
  191.         foreach ($this->getVariants() as $variant) {
  192.                 $minWeights[] = $variant->getWeight();
  193.         }
  194.         return count($minWeights) > 0 ? min($minWeights) : 0;
  195.     }
  197.     public function getUniqueSizes() 
  198.     {
  199.         $sizes = [];
  200.         foreach ($this->getVariants() as $variant) {
  201.             $sizes[] = $variant->getOptionValues()->get(1)->getValue();
  202.         }
  203.         return array_unique($sizes);
  204.     }
  207.     public function getImagesByColor()
  208.     {
  209.         $imagesByColor = [];
  210.         foreach ($this->getVariants() as $variant) {
  211.             $color = $variant->getOptionValues()->get(0)->getValue();
  212.             if (!isset($imagesByColor[$color])) {
  213.                 $imagesByColor[$color] = $variant->getImages();
  214.             }
  215.         }
  216.         return $imagesByColor;
  217.     }
  219.     public function hasInStockVariant()
  220.     {
  221.         foreach ($this->getVariants() as $variant) {
  222.             if (intval($variant->getQuantity()) > 0) {
  223.                 return true;
  224.             }
  225.         }
  226.         return false;
  227.     }
  228.     public function getUniqueColors()
  229.     {
  230.         $colors = [];
  231.         foreach ($this->getVariants() as $variant) {
  232.             $colors[] = $variant->getOptionValues()->get(0)->getValue();
  233.         }
  234.         return array_unique($colors);
  235.     }
  236.     public function setWeight(?float $weight): self
  237.     {
  238.         $this->weight = $weight;
  240.         return $this;
  241.     }
  243.     // public function getMainImage(): ?string
  244.     // {
  245.     //     return '/uploads/tbint/'.strval($this->apiId).'/'.$this->mainImage;
  246.     // }
  248.     public function getMainImage(): ?string
  249.     {
  250.         return $this->mainImage;
  251.     }
  253.     public function setMainImage(?string $mainImage): self
  254.     {
  255.         $this->mainImage = $mainImage;
  257.         return $this;
  258.     }
  261.     public function getPrice(): ?float
  262.     {
  263.         return $this->price;
  264.     }
  266.     public function setPrice(float $price): self
  267.     {
  268.         $this->price = $price;
  270.         return $this;
  271.     }
  273.     public function getRetailPrice(): ?float
  274.     {
  275.         return $this->retailPrice;
  276.     }
  278.     public function setRetailPrice(?float $retailPrice): self
  279.     {
  280.         $this->retailPrice = $retailPrice;
  282.         return $this;
  283.     }
  285.     public function getDescription(): ?string
  286.     {
  287.         return $this->description;
  288.     }
  290.     public function setDescription(string $description): self
  291.     {
  292.         $this->description = $description;
  294.         return $this;
  295.     }
  297.     public function getEan(): ?string
  298.     {
  299.         return $this->ean;
  300.     }
  302.     public function setEan(string $ean): self
  303.     {
  304.         $this->ean = $ean;
  306.         return $this;
  307.     }
  309.     public function getSlug(): ?string
  310.     {
  311.         return $this->slug;
  312.     }
  314.     public function setSlug(string $slug): self
  315.     {
  316.         $slug = preg_replace('/[^A-Za-z0-9-]+/', '-', $this->getName());
  317.         $this->slug = $slug;
  318.         return $this;
  319.     }
  321.     // /**
  322.     //  * @return Collection<int, ProductVariant>
  323.     //  */
  324.     // public function getVariants(): ?Collection
  325.     // {
  326.     //     return $this->variants;
  327.     // }
  329.     public function firstVariantId()
  330.     {
  331.         return $this->variants->first()->getId();
  332.     }
  334.     public function firstVariantFrontImage()
  335.     {
  336.         return $this->variants->first()->getMainImage();
  337.     }
  339.     public function firstVariantBackImage()
  340.     {
  341.         return $this->variants->first()->getBackImage();
  342.     }
  344.     public function firstVariantPrice()
  345.     {
  346.         return $this->variants->first()->getSellingPrice();
  347.     }
  349.     // public function getVariantesByColor()
  350.     // {
  351.     //     $test = $this->variants->filter(function($variant){
  353.     //     })
  354.     // }
  356.     // public function addVariant(ProductVariant $variant): self
  357.     // {
  358.     //     if (!$this->variants->contains($variant)) {
  359.     //         $this->variants->add($variant);
  360.     //     }
  362.     //     return $this;
  363.     // }
  365.     // public function removeVariant(ProductVariant $variant): self
  366.     // {
  367.     //     $this->variants->removeElement($variant);
  369.     //     return $this;
  370.     // }
  373.     public function getSecondImage()
  374.     {
  375.         $images = array_values(array_filter($this->images));
  376.         $randomIndex = rand(0,count($images) - 1);
  377.         $img = !empty($images) ? $images[$randomIndex] : null;
  378.         return $img;
  379.     }
  381.     public function getColor($color)
  382.     {
  383.         return $this->variants->findFirst(function($variant) use ($color){
  384.             return strtolower($variant->getColor()) ==  strtolower($color);
  385.         });
  386.     }
  388.     public function getCollectionName(): ?string
  389.     {
  390.         return $this->collection_name;
  391.     }
  393.     public function setCollectionName(string $collection_name): static
  394.     {
  395.         $this->collection_name = $collection_name;
  397.         return $this;
  398.     }
  400.     public function mainImageTag(): string
  401.     {
  403.         return "<img src='" + $this->mainImage + "'>";
  404.     }
  406.     /**
  407.      * @return Collection<int, Category>
  408.      */
  409.     public function getCategories(): Collection
  410.     {
  411.         return $this->categories;
  412.     }
  414.     public function addCategory(Category $category): static
  415.     {
  416.         if (!$this->categories->contains($category)) {
  417.             $this->categories->add($category);
  418.         }
  420.         return $this;
  421.     }
  423.     public function removeCategory(Category $category): static
  424.     {
  425.         $this->categories->removeElement($category);
  427.         return $this;
  428.     }
  430.     /**
  431.      * @return Collection<int, Option>
  432.      */
  433.     public function getOptions(): Collection
  434.     {
  435.         return $this->options;
  436.     }
  438.     public function addOption(Option $option): static
  439.     {
  440.         if (!$this->options->contains($option)) {
  441.             $this->options->add($option);
  442.             $option->setProduct($this);
  443.         }
  445.         return $this;
  446.     }
  448.     public function removeOption(Option $option): static
  449.     {
  450.         if ($this->options->removeElement($option)) {
  451.             // set the owning side to null (unless already changed)
  452.             if ($option->getProduct() === $this) {
  453.                 $option->setProduct(null);
  454.             }
  455.         }
  457.         return $this;
  458.     }
  461.     public function getImages(): array
  462.     {
  463.         return $this->images;
  464.     }
  466.     public function setImages(?array $images): static
  467.     {
  468.         $this->images = $images;
  470.         return $this;
  471.     }
  473.     
  474.     public function __toString()
  475.     {
  476.         return $this->name ?? 'pid:'.strval($this->id);
  477.     }
  479.     public function getProfitMargin(): ?float
  480.     {
  481.         return $this->profitMargin;
  482.     }
  484.     public function setProfitMargin(?float $profitMargin): static
  485.     {
  486.         $this->profitMargin = $profitMargin;
  488.         return $this;
  489.     }
  491.     public function getPromotionMargin(): ?float
  492.     {
  493.         return $this->promotionMargin;
  494.     }
  496.     public function setPromotionMargin(?float $promotionMargin): static
  497.     {
  498.         $this->promotionMargin = $promotionMargin;
  500.         return $this;
  501.     }
  503.     /**
  504.      * @return Collection<int, ProductCollection>
  505.      */
  506.     public function getCollections(): Collection
  507.     {
  508.         return $this->collections;
  509.     }
  511.     public function addCollection(ProductCollection $collection): static
  512.     {
  513.         if (!$this->collections->contains($collection)) {
  514.             $this->collections->add($collection);
  515.         }
  517.         return $this;
  518.     }
  520.     public function removeCollection(ProductCollection $collection): static
  521.     {
  522.         $this->collections->removeElement($collection);
  524.         return $this;
  525.     }
  527.     public function getApiLastUpdated(): ?string
  528.     {
  529.         return $this->api_last_updated;
  530.     }
  532.     public function setApiLastUpdated(?string $api_last_updated): static
  533.     {
  534.         $this->api_last_updated = $api_last_updated;
  536.         return $this;
  537.     }
  539.     public function getModelId(): ?string
  540.     {
  541.         return $this->modelId;
  542.     }
  544.     public function setModelId(?string $modelId): static
  545.     {
  546.         $this->modelId = $modelId;
  548.         return $this;
  549.     }
  551.     /**
  552.      * @return Collection<int, ProductVariant>
  553.      */
  554.     public function getVariants(): Collection
  555.     {
  556.         return $this->variants;
  557.     }
  559.     public function addVariant(ProductVariant $variant): static
  560.     {
  561.         if (!$this->variants->contains($variant)) {
  562.             $this->variants->add($variant);
  563.             $variant->setProduct($this);
  564.         }
  566.         return $this;
  567.     }
  569.     public function removeVariant(ProductVariant $variant): static
  570.     {
  571.         if ($this->variants->removeElement($variant)) {
  572.             // set the owning side to null (unless already changed)
  573.             if ($variant->getProduct() === $this) {
  574.                 $variant->setProduct(null);
  575.             }
  576.         }
  578.         return $this;
  579.     }
  581.     public function getApiId(): ?string
  582.     {
  583.         return $this->apiId;
  584.     }
  586.     public function setApiId(string $apiId): static
  587.     {
  588.         $this->apiId = $apiId;
  590.         return $this;
  591.     }
  593.     public function getSupplier(): ?Suplier
  594.     {
  595.         return $this->supplier;
  596.     }
  598.     public function getSupplierName(): ?string
  599.     {
  600.         return $this->supplier->getName();
  601.     }
  603.     public function setSupplier(?Suplier $supplier): static
  604.     {
  605.         $this->supplier = $supplier;
  607.         return $this;
  608.     }
  610.     public function getMediaPath(): ?string
  611.     {
  612.         return $this->mediaPath;
  613.     }
  615.     public function setMediaPath(?string $mediaPath): static
  616.     {
  617.         $this->mediaPath = $mediaPath;
  619.         return $this;
  620.     }
  622.     public function getImagePathForAdmin(): ?string
  623.     {
  624.         $arr = explode('/',$this->mainImage);
  625.         $path = array_pop($arr);
  626.         return $path;
  627.     }
  629.     public function getImagesPathForAdmin(): ?array
  630.     {   
  631.         if($this->images){
  632.             return array_map(function($image){
  633.                 $arr = explode('/',$image);
  634.                 $path = array_pop($arr);
  635.                 return $path;
  636.             },$this->images);
  637.         }else{
  638.             return [];
  639.         }
  640.     }
  642.     public function setImagesPathForAdmin(?array $images): static
  643.     {
  644.         if($images){
  645.             $this->images = array_map(function($image){
  646.                                 return $this->mediaPath.'/'.$image;
  647.                             },$images);
  648.         }else{
  649.             $this->images = [];
  650.         }
  651.         return $this;
  652.     }
  654.     public function setImagePathForAdmin(?string $image): static
  655.     {
  656.         if($image){
  657.             $this->mainImage = $this->mediaPath.'/'.$image;
  658.         }
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return Collection<int, MarketPlace>
  664.      */
  665.     public function getMarketPlaces(): Collection
  666.     {
  667.         return $this->marketPlaces;
  668.     }
  670.     public function addMarketPlace(MarketPlace $marketPlace): static
  671.     {
  672.         if (!$this->marketPlaces->contains($marketPlace)) {
  673.             $this->marketPlaces->add($marketPlace);
  674.             $marketPlace->addProduct($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeMarketPlace(MarketPlace $marketPlace): static
  681.     {
  682.         if ($this->marketPlaces->removeElement($marketPlace)) {
  683.             $marketPlace->removeProduct($this);
  684.         }
  686.         return $this;
  687.     }
  689.     /**
  690.      * @return Collection<int, Listing>
  691.      */
  692.     public function getListings(): Collection
  693.     {
  694.         return $this->listings;
  695.     }
  697.     public function addListing(Listing $listing): static
  698.     {
  699.         if (!$this->listings->contains($listing)) {
  700.             $this->listings->add($listing);
  701.             $listing->setProduct($this);
  702.         }
  704.         return $this;
  705.     }
  707.     public function removeListing(Listing $listing): static
  708.     {
  709.         if ($this->listings->removeElement($listing)) {
  710.             // set the owning side to null (unless already changed)
  711.             if ($listing->getProduct() === $this) {
  712.                 $listing->setProduct(null);
  713.             }
  714.         }
  716.         return $this;
  717.     }
  719. }