src/Entity/ProductVariant.php line 15

  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;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Gedmo\Translatable\Translatable;
  12. use Gedmo\Mapping\Annotation as Gedmo;
  14. #[ORM\Entity(repositoryClass: ProductVariantRepository::class)]
  15. class ProductVariant implements Translatable
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[Gedmo\Locale]
  23.     private $locale;
  25.     #[Gedmo\Translatable]
  26.     #[ORM\Column(length: 255)]
  27.     private ?string $name = null;
  29.     #[ORM\Column(length: 255, nullable: true)]
  30.     private ?string $category = null;
  32.     #[Gedmo\Translatable]
  33.     #[ORM\Column(length: 500, nullable: true)]
  34.     private ?string $composition = null;
  36.     #[ORM\Column(nullable: true)]
  37.     private ?int $quantity = null;
  39.     #[ORM\Column(nullable: true)]
  40.     private ?float $weight = null;
  42.     #[ORM\Column(length: 255, nullable: true)]
  43.     private ?string $mainImage = null;
  46.     #[ORM\Column]
  47.     private ?float $price = null;
  49.     #[ORM\Column(nullable: true)]
  50.     private ?float $retailPrice = null;
  52.     #[Gedmo\Translatable]
  53.     #[ORM\Column(type: Types::TEXT)]
  54.     private ?string $description = null;
  56.     #[ORM\Column(length: 255)]
  57.     private ?string $ean = null;
  59.     #[ORM\Column(length: 255, nullable: true)]
  60.     private ?string $slug = null;
  62.     // #[ORM\ManyToOne(targetEntity: Product::class, inversedBy: 'variants')]
  63.     // #[ORM\JoinColumn(nullable: false)]
  64.     // private $product;
  66.     #[ORM\OneToMany(mappedBy: 'productVariant', targetEntity: Size::class,cascade: ['persist'],orphanRemoval:true)]
  67.     private Collection $sizes;
  69.     #[ORM\Column(length: 255)]
  70.     private ?string $stripeId = null;
  73.     #[ORM\OneToMany(mappedBy: 'productVariant', targetEntity: OptionValue::class,orphanRemoval: true)]
  74.     private Collection $optionValues;
  76.     #[ORM\OneToMany(mappedBy: 'productVariant', targetEntity: OrderItem::class, orphanRemoval: true)]
  77.     private Collection $orderItems;
  79.     #[ORM\Column(length: 255, nullable: true)]
  80.     private ?string $color = null;
  82.     #[ORM\Column(nullable: true)]
  83.     private array $images = [];
  85.     #[ORM\Column(nullable: true)]
  86.     private ?float $promotionRate = null;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?float $profitMargin = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $stripeObjId = null;
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $api_last_updated = null;
  97.     #[ORM\Column(nullable: true)]
  98.     private ?float $sellingPrice = null;
  100.     #[ORM\ManyToOne(inversedBy: 'variants')]
  101.     #[ORM\JoinColumn(nullable: false)]
  102.     private ?Product $product = null;
  104.     #[ORM\Column(length: 255)]
  105.     private ?string $apiId = null;
  107.     #[ORM\Column(length: 255, nullable: true)]
  108.     private ?string $mediaPath = null;
  111.     public function __construct()
  112.     {
  113.         $this->sizes = new ArrayCollection();
  114.         $this->optionValues = new ArrayCollection();
  115.         $this->orderItems = new ArrayCollection();
  116.     }
  118.     public function getId(): ?int
  119.     {
  120.         return $this->id;
  121.     }
  123.     public function getName(): ?string
  124.     {
  125.         return $this->name;
  126.     }
  128.     public function setName(string $name): self
  129.     {
  130.         $this->name = $name;
  132.         return $this;
  133.     }
  135.     public function setEan(string $ean): self
  136.     {
  137.         $this->ean = $ean;
  139.         return $this;
  140.     }
  143.     public function setDescription(string $description): self
  144.     {
  145.         $this->description = $description;
  147.         return $this;
  148.     }
  150.     public function setCategory(string $category): self
  151.     {
  152.         $this->category = $category;
  154.         return $this;
  155.     }
  157.     public function setComposition(string $composition): self
  158.     {
  159.         $this->composition = $composition;
  161.         return $this;
  162.     }
  164.     public function setQuantity(string $quantity): self
  165.     {
  166.         $this->quantity = $quantity;
  168.         return $this;
  169.     }
  172.     public function setWeight(string $weight): self
  173.     {
  174.         $this->weight = $weight;
  176.         return $this;
  177.     }
  179.     public function setMainImage(string $mainImage): self
  180.     {
  181.         $this->mainImage = $mainImage;
  183.         return $this;
  184.     }
  187.     public function getPrice(): ?float
  188.     {
  189.         return $this->price;
  190.     }
  192.     public function setPrice(float $price): self
  193.     {
  194.         $this->price = $price;
  196.         return $this;
  197.     }
  200.     public function setretailPrice(float $retailPrice): self
  201.     {
  202.         $this->retailPrice = $retailPrice;
  204.         return $this;
  205.     }
  208.     /**
  209.      * @return Collection<int, Size>
  210.      */
  211.     public function getSizes(): Collection
  212.     {
  213.         return $this->sizes;
  214.     }
  216.     public function addSize(Size $size): static
  217.     {
  218.         if (!$this->sizes->contains($size)) {
  219.             $this->sizes->add($size);
  220.             $size->setProductVariant($this);
  221.         }
  223.         return $this;
  224.     }
  226.     public function removeSize(Size $size): static
  227.     {
  228.         if ($this->sizes->removeElement($size)) {
  229.             // set the owning side to null (unless already changed)
  230.             if ($size->getProductVariant() === $this) {
  231.                 $size->setProductVariant(null);
  232.             }
  233.         }
  235.         return $this;
  236.     }
  238.     public function getStripeId(): ?string
  239.     {
  240.         return $this->stripeId;
  241.     }
  243.     public function setStripeId(string $stripeId): static
  244.     {
  245.         $this->stripeId = $stripeId;
  247.         return $this;
  248.     }
  251.     public function getCategory(): ?string
  252.     {
  253.         return $this->category;
  254.     }
  256.     public function getComposition(): ?string
  257.     {
  258.         return $this->composition;
  259.     }
  261.     public function getQuantity(): ?int
  262.     {
  263.         return $this->quantity;
  264.     }
  266.     public function getWeight(): ?float
  267.     {
  268.         return $this->weight;
  269.     }
  271.     // public function getMainImage(): ?string
  272.     // {
  273.     //     return '/uploads/tbint/'.strval($this->apiId).'/'.$this->mainImage;
  274.     // }
  276.     public function getMainImage(): ?string
  277.     {
  278.         return $this->mainImage;
  279.     }
  281.     public function getBackImage(): ?string
  282.     {
  283.         $images = array_values(array_filter($this->images));
  284.         $randomIndex = rand(0,count($images) - 1);
  285.         $img = !empty($images) ? $images[$randomIndex] : 'null';
  286.         return $img;
  287.     }
  289.     public function getRetailPrice(): ?float
  290.     {
  291.         return $this->retailPrice;
  292.     }
  294.     public function getDescription(): ?string
  295.     {
  296.         return $this->description;
  297.     }
  299.     public function getEan(): ?string
  300.     {
  301.         return $this->ean;
  302.     }
  304.     public function getSlug(): ?string
  305.     {
  306.         return $this->slug;
  307.     }
  309.     public function setSlug(?string $slug): static
  310.     {
  311.         $this->slug = $slug;
  313.         return $this;
  314.     }
  316.     // public function getProduct(): ?Product
  317.     // {
  318.     //     return $this->product;
  319.     // }
  321.     // public function setProduct(?Product $product): static
  322.     // {
  323.     //     $this->product = $product;
  325.     //     return $this;
  326.     // }
  328.     /**
  329.      * @return Collection<int, OptionValue>
  330.      */
  331.     public function getOptionValues(): Collection
  332.     {
  333.         return $this->optionValues;
  334.     }
  336.     public function addOptionValue(OptionValue $optionValue): static
  337.     {
  338.         if (!$this->optionValues->contains($optionValue)) {
  339.             $this->optionValues->add($optionValue);
  340.             $optionValue->setProductVariant($this);
  341.         }
  343.         return $this;
  344.     }
  346.     public function removeOptionValue(OptionValue $optionValue): static
  347.     {
  348.         if ($this->optionValues->removeElement($optionValue)) {
  349.             // set the owning side to null (unless already changed)
  350.             if ($optionValue->getProductVariant() === $this) {
  351.                 $optionValue->setProductVariant(null);
  352.             }
  353.         }
  355.         return $this;
  356.     }
  358.     /**
  359.      * @return Collection<int, OrderItem>
  360.      */
  361.     public function getOrderItems(): Collection
  362.     {
  363.         return $this->orderItems;
  364.     }
  366.     public function addOrderItem(OrderItem $orderItem): static
  367.     {
  368.         if (!$this->orderItems->contains($orderItem)) {
  369.             $this->orderItems->add($orderItem);
  370.             $orderItem->setProductVariant($this);
  371.         }
  373.         return $this;
  374.     }
  376.     public function removeOrderItem(OrderItem $orderItem): static
  377.     {
  378.         if ($this->orderItems->removeElement($orderItem)) {
  379.             // set the owning side to null (unless already changed)
  380.             if ($orderItem->getProductVariant() === $this) {
  381.                 $orderItem->setProductVariant(null);
  382.             }
  383.         }
  385.         return $this;
  386.     }
  388.     public function getColor(): ?string
  389.     {
  390.         return $this->color;
  391.     }
  393.     public function setColor(?string $color): static
  394.     {
  395.         $this->color = $color;
  397.         return $this;
  398.     }
  400.     public function getImages(): array
  401.     {
  402.         return $this->images;
  403.     }
  405.     public function setImages(?array $images): static
  406.     {
  407.         $this->images = $images;
  409.         return $this;
  410.     }
  412.     public function __toString()
  413.     {
  414.         return $this->name ?? '';
  415.     }
  417.     public function getPromotionRate(): ?float
  418.     {
  419.         return $this->promotionRate;
  420.     }
  422.     public function setPromotionRate(?float $promotionRate): static
  423.     {
  424.         $this->promotionRate = $promotionRate;
  426.         return $this;
  427.     }
  429.     public function getProfitMargin(): ?float
  430.     {
  431.         return $this->profitMargin;
  432.     }
  434.     public function setProfitMargin(?float $profitMargin): static
  435.     {
  436.         $this->profitMargin = $profitMargin;
  438.         return $this;
  439.     }
  441.     public function getStripeObjId(): ?string
  442.     {
  443.         return $this->stripeObjId;
  444.     }
  446.     public function setStripeObjId(?string $stripeObjId): static
  447.     {
  448.         $this->stripeObjId = $stripeObjId;
  450.         return $this;
  451.     }
  453.     public function getApiLastUpdated(): ?string
  454.     {
  455.         return $this->api_last_updated;
  456.     }
  458.     public function setApiLastUpdated(?string $api_last_updated): static
  459.     {
  460.         $this->api_last_updated = $api_last_updated;
  462.         return $this;
  463.     }
  465.     public function getSellingPrice(): ?float
  466.     {
  467.         return $this->sellingPrice;
  468.     }
  470.     public function setSellingPrice(?float $sellingPrice): static
  471.     {
  472.         if ($this->profitMargin) {
  473.             $this->sellingPrice = ( 1 + $this->profitMargin / 100 ) * $this->price;
  474.         }else{
  475.             $this->sellingPrice = $sellingPrice;
  476.         }
  477.         return $this;
  478.     }
  480.     public function getProduct(): ?Product
  481.     {
  482.         return $this->product;
  483.     }
  485.     public function setProduct(?Product $product): static
  486.     {
  487.         $this->product = $product;
  489.         return $this;
  490.     }
  492.     public function getApiId(): ?string
  493.     {
  494.         return $this->apiId;
  495.     }
  497.     public function setApiId(string $apiId): static
  498.     {
  499.         $this->apiId = $apiId;
  501.         return $this;
  502.     }
  503.     
  504.     public function setTranslatableLocale($locale)
  505.     {
  506.         $this->locale = $locale;
  507.     }
  509.     public function getMediaPath(): ?string
  510.     {
  511.         return $this->mediaPath;
  512.     }
  514.     public function setMediaPath(?string $mediaPath): static
  515.     {
  516.         $this->mediaPath = $mediaPath;
  518.         return $this;
  519.     }
  521.     public function getImagePathForAdmin(): ?string
  522.     {
  523.         $arr = explode('/',$this->mainImage);
  524.         $path = array_pop($arr);
  525.         return $path;
  526.     }
  528.     public function setImagePathForAdmin(?string $image): static
  529.     {
  530.         if($image){
  531.             $this->mainImage = $this->mediaPath.'/'.$image;
  532.         }
  533.         return $this;
  534.     }
  536.     public function getImagesPathForAdmin(): ?array
  537.     {   
  538.         if($this->images){
  539.             return array_map(function($image){
  540.                     $arr = explode('/',$image);
  541.                     $path = array_pop($arr);
  542.                     return $path;
  543.                  },$this->images);
  544.         }else{
  545.             return [];
  546.         }
  547.     }
  549.     public function setImagesPathForAdmin(?array $images): static
  550.     {
  551.         if($images){
  552.             $this->images = array_map(function($image){
  553.                                 return $this->mediaPath.'/'.$image;
  554.                             },$images);
  555.         }else{
  556.             $this->images = [];
  557.         }
  558.         return $this;
  559.     }
  560. }