src/Entity/Product.php line 34

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Media;
  6. use App\Repository\ProductRepository;
  7. use DateInterval;
  8. use DateTime;
  9. use App\SlugHandler\ProductNameSlugHandler;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Doctrine\Common\Collections\Criteria;
  13. use Doctrine\DBAL\Types\Types;
  14. use Gedmo\Mapping\Annotation\Slug;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Doctrine\ORM\Mapping\PrePersist;
  17. use Gedmo\Blameable\Traits\BlameableEntity;
  18. use Gedmo\Mapping\Annotation\SlugHandler;
  19. use Gedmo\Mapping\Annotation\Translatable;
  20. use Gedmo\Sluggable\Handler\InversedRelativeSlugHandler;
  21. use Gedmo\Sluggable\Handler\RelativeSlugHandler;
  22. use Gedmo\Timestampable\Traits\TimestampableEntity;
  23. use Knp\DoctrineBehaviors\Contract\Entity\TranslatableInterface;
  24. use Knp\DoctrineBehaviors\Model\Translatable\TranslatableTrait;
  25. use Symfony\Component\PropertyAccess\PropertyAccess;
  26. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  27. use Symfony\Component\Serializer\Annotation\SerializedName;
  28. use Symfony\Component\Validator\Constraints as Assert;
  30. #[ORM\MappedSuperclass()]
  31. #[UniqueEntity('slug')]
  32. #[ORM\HasLifecycleCallbacks]
  33. #[ORM\Entity(repositoryClass: ProductRepository::class)]
  34. class Product implements TranslatableInterface
  35. {
  36.     use BlameableEntity; //Hook blameable behaviour. Updates createdBy, updatedBy fields
  37.     use TimestampableEntity; //Hook timestampable behaviour. Updates createdAt, updatedAt fields 
  38.     use TranslatableTrait;
  40.     const STATUS_DRAFT = 'DRAFT';
  41.     const STATUS_SCHEDULED = 'SCHEDULED';
  42.     const STATUS_ACTIVE = 'ACTIVE';
  43.     const STATUS_BLOCKED = 'BLOCKED';
  44.     const STATUS_FINISHED = 'FINISHED';
  46.     const DEFAULT_SHIPPING_INDIVIDUAL_DURANTION = 3;
  47.     const DEFAULT_SHIPPING_SHARED_DURANTION = 8;
  49.     #[Assert\Valid]
  50.     protected $translations;
  52.     #[ORM\Id]
  53.     #[ORM\GeneratedValue(strategy: "IDENTITY")]
  54.     #[ORM\Column]
  55.     private ?int $id = null;
  57.     #[ORM\Column(length: 255, unique: true, updatable:true)]
  58.     #[Slug(fields: ['slug'])]
  59.     private ?string $slug = null;
  61.     #[ORM\ManyToOne(inversedBy: 'products')]
  62.     #[ORM\JoinColumn(nullable: false)]
  63.     #[Assert\NotNull()]
  64.     private ?ProductType $type = null;
  66.     #[ORM\Column]
  67.     #[Assert\NotNull()]
  68.     private ?bool $isDraft = true;
  70.     #[ORM\Column]
  71.     #[Assert\NotNull()]
  72.     private ?bool $isBlocked = false;
  74.     #[ORM\Column]
  75.     #[Assert\NotNull()]
  76.     private ?bool $isSoldOut = false;
  78.     #[ORM\Column(nullable: true)]
  79.     #[Assert\Positive()]
  80.     #[Assert\Expression(
  81.         "!this.getShipping() || (this.getVolumetricWeight() || value)",
  82.     )]
  83.     private ?float $weight = null;
  85.     #[ORM\Column(nullable: true)]
  86.     #[Assert\Positive()]
  87.     private ?int $width = null;
  89.     #[ORM\Column(nullable: true)]
  90.     #[Assert\Positive()]
  91.     private ?int $length = null;
  93.     #[ORM\Column(nullable: true)]
  94.     #[Assert\Positive()]
  95.     private ?int $height = null;
  97.     #[ORM\Column(nullable: true)]
  98.     #[Assert\Positive()]
  99.     #[Assert\Expression(
  100.         "!this.getShipping() || (this.getWeight() || value)",
  101.     )]
  102.     private ?float $volumetricWeight = null;
  104.     #[ORM\Column(nullable: true)]
  105.     #[Assert\Positive()]
  106.     private ?int $unitsPerBox = 1;
  108.     #[ORM\Column(nullable: true)]
  109.     #[Assert\Positive()]
  110.     private ?int $unitsPerBoxGrouped = 1;
  112.     #[ORM\Column]
  113.     #[Assert\NotNull()]
  114.     private ?bool $hideDiscount = false;
  116.     #[ORM\Column(length: 50, nullable: true)]
  117.     #[Assert\Length(max: 50)]
  118.     private ?string $ean = null;
  120.     #[ORM\ManyToMany(targetEntity: Category::class, inversedBy: 'products')]
  121.     #[Assert\Count(min: 1)]
  122.     private Collection $categories;
  124.     #[ORM\ManyToMany(targetEntity: Subcategory::class, inversedBy: 'products')]
  125.     private Collection $subcategories;
  127.     #[ORM\Column(length: 50, nullable: true)]
  128.     #[Assert\Length(max: 50)]
  129.     private ?string $purchaseOrderNumber = null;
  131.     #[ORM\OneToMany(mappedBy: 'productImage', targetEntity: Media::class, cascade: ["persist", "remove"])]
  132.     #[ORM\OrderBy(["position" => "ASC"])]
  133.     private Collection $productImages;
  135.     #[ORM\OneToMany(mappedBy: 'productVideo', targetEntity: Media::class, cascade: ["persist", "remove"])]
  136.     private Collection $productVideos;
  138.     #[ORM\ManyToMany(targetEntity: Label::class, inversedBy: 'products')]
  139.     private Collection $labels;
  141.     #[ORM\Column]
  142.     #[Assert\NotNull()]
  143.     private ?bool $isMandatoryProductFeatures = false;
  145.     #[ORM\Column]
  146.     #[Assert\NotNull()]
  147.     private ?bool $isMandatoryProducer = false;
  149.     #[ORM\Column(nullable: true)]
  150.     private ?bool $isMandatoryTriweerList = false;
  152.     #[ORM\Column(nullable: true)]
  153.     private ?bool $isMandatoryTriweerComments = false;
  155.     #[ORM\Column]
  156.     #[Assert\NotNull()]
  157.     private ?bool $isLiveShopping = false;
  159.     #[ORM\Column]
  160.     #[Assert\NotNull()]
  161.     private ?bool $hasBlockchainTraceability = false;
  163.     #[ORM\Column]
  164.     #[Assert\NotNull()]
  165.     private ?bool $showOnWall = true;
  167.     #[ORM\Column]
  168.     #[Assert\NotNull()]
  169.     private ?bool $allowReturn = false;
  171.     #[ORM\Column(nullable: true)]
  172.     #[Assert\Expression(
  173.         "this.getAllowReturn() == false || value",
  174.     )]
  175.     #[Assert\Positive()]
  176.     private ?int $nDaysAllowedForReturn = null;
  178.     #[ORM\Column]
  179.     #[Assert\NotNull()]
  180.     private ?bool $sendNotifications = true;
  182.     #[ORM\Column(length: 255, nullable: true)]
  183.     #[Assert\Length(max: 255)]
  184.     private ?string $producerPurchaseOrderNumber = null;
  186.     #[ORM\Column]
  187.     #[Assert\NotNull()]
  188.     #[Assert\Positive()]
  189.     private ?int $limitUnitsPerBuyer = null;
  191.     #[ORM\Column(nullable: true)]
  192.     #[Assert\Positive()]
  193.     private ?int $limitUnitsToSell = null;
  195.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  196.     #[Assert\NotNull()]
  197.     private ?\DateTimeInterface $comingSoonDate = null;
  199.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  200.     #[Assert\NotNull()]
  201.     private ?\DateTimeInterface $offerLaunchDate = null;
  203.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  204.     #[Assert\NotNull()]
  205.     private ?\DateTimeInterface $countdownDate = null;
  207.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  208.     #[Assert\NotNull()]
  209.     private ?\DateTimeInterface $endOfferDate = null;
  211.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  212.     //#[Assert\NotNull()]
  213.     private ?\DateTimeInterface $shippingDate = null;
  215.     #[ORM\Column(nullable: true)]
  216.     #[Assert\PositiveOrZero()]
  217.     // #[Assert\NotNull()]
  218.     private ?int $individualShippingDuration = null;
  220.     #[ORM\Column(nullable: true)]
  221.     #[Assert\PositiveOrZero()]
  222.     // #[Assert\NotNull()]
  223.     private ?int $sharedShippingDuration = null;
  225.     #[ORM\Column(length: 255, nullable: true)]
  226.     #[Assert\Length(max: 255)]
  227.     private ?string $individualPackageFormat = null;
  229.     #[ORM\Column]
  230.     #[Assert\NotNull()]
  231.     #[Assert\PositiveOrZero()]
  232.     private ?int $nHoursOnWallAfterEnd = null;
  234.     #[ORM\ManyToOne(inversedBy: 'products')]
  235.     #[ORM\JoinColumn(nullable: false)]
  236.     #[Assert\NotNull()]
  237.     private ?Iva $iva = null;
  239.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: ProductPriceScale::class, cascade: ["persist", "remove"], orphanRemoval: true)]
  240.     #[ORM\OrderBy(["initialPrice" => "DESC"])]
  241.     #[Assert\Count(min: 1)]
  242.     #[Assert\Valid]
  243.     private Collection $priceScales;
  245.     #[ORM\Column]
  246.     #[Assert\NotNull()]
  247.     #[Assert\PositiveOrZero()]
  248.     private ?int $maxCoinsToSpent = null;
  250.     #[ORM\ManyToOne(inversedBy: 'products')]
  251.     #[ORM\JoinColumn(nullable: true)]
  252.     #[Assert\NotNull()]
  253.     private ?Brand $brand = null;
  255.     #[ORM\ManyToOne(inversedBy: 'products')]
  256.     #[Assert\Expression(
  257.         "this.getIsMandatoryProducer() == false || value",
  258.     )]
  259.     private ?Producer $producer = null;
  261.     #[ORM\ManyToOne(inversedBy: 'products')]
  262.     #[ORM\JoinColumn(nullable: false)]
  263.     #[Assert\NotNull()]
  264.     private ?UnitMeasurement $unitMeasurement = null;
  266.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: OrderDetail::class)]
  267.     private Collection $orderDetails;
  269.     #[ORM\Column]
  270.     #[Assert\NotNull()]
  271.     #[Assert\Positive()]
  272.     private ?float $originalPrice = null;
  274.     #[ORM\Column(nullable: true)]
  275.     #[Assert\Positive()]
  276.     private ?float $individualPrice = null;
  278.     #[ORM\Column(options: ['default' => false])]
  279.     private ?bool $individualDisabled = false;
  281.     #[ORM\Column(options: ['default' => 0])]
  282.     #[Assert\NotNull()]
  283.     #[Assert\PositiveOrZero()]
  284.     #[Assert\Expression(
  285.         "value <= this.getProductMaxQuantity()",
  286.     )]
  287.     private ?int $fakeUsers = 0;
  289.     #[ORM\JoinTable(name: 'faketriweers_product')]
  290.     #[ORM\JoinColumn(name: 'fake_triweer_id', referencedColumnName: 'id')]
  291.     #[ORM\InverseJoinColumn(name: 'product_id', referencedColumnName: 'id')]
  292.     #[ORM\ManyToMany(targetEntity: User::class)]
  293.     private Collection $fakeTriweersInOffer;
  295.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  296.     private ?string $additionalInfo = null;
  298.     /**
  299.      * @deprecated
  300.      */
  301.     #[ORM\Column(nullable: true)]
  302.     #[Assert\PositiveOrZero()]
  303.     private ?float $shippingCost = null;
  305.     #[ORM\Column(length: 500, nullable: true)]
  306.     private ?string $holdedId = null;
  308.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: UserShared::class)]
  309.     private Collection $influencerShareds;
  311.     #[ORM\ManyToOne(inversedBy: 'products')]
  312.     #[ORM\JoinColumn(nullable: false)]
  313.     #[Assert\NotNull()]
  314.     private ?ProductUnique $productUnique = null;
  316.     #[ORM\Column(options: ['default' => false])]
  317.     private ?bool $onlyAdults = false;
  319.     #[ORM\Column(nullable: true)]
  320.     #[Assert\PositiveOrZero()]
  321.     private ?int $amountForFreeShipping = null;
  323.     #[ORM\Column(nullable: true)]
  324.     private ?bool $better_price = null;
  326.     #[ORM\ManyToOne(inversedBy: 'products')]
  327.     #[Assert\NotNull()]
  328.     private ?Shipping $shipping = null;
  330.     #[ORM\ManyToMany(targetEntity: User::class, mappedBy: "favouriteProducts")]
  331.     private Collection $userFavourites;
  333.     private Collection $randomUserFavourites;
  335.     #[ORM\OneToMany(mappedBy: 'product', targetEntity: Review::class)]
  336.     private Collection $userReviews;
  338.     #[ORM\Column(length: 255, nullable: true)]
  339.     private ?string $meta_title = null;
  341.     #[ORM\Column(length: 255, nullable: true)]
  342.     private ?string $meta_description = null;
  344.     #[ORM\Column(nullable: false, options: ['default' => false])]
  345.     private ?bool $showPrice = false;
  347.     #[ORM\PrePersist]
  348.     
  349.     public function setSlugValue()
  350.     {
  351.         $this->setSlug($this->translate('es')->getName());
  352.     }
  354.     public function setSlugEditValue()
  355.     {
  356.         $name = $this->translate('es')->getName() ?? '';
  357.         $this->setSlug($this->generateSlug($name)); 
  358.     }
  360.     private function generateSlug(string $name): string
  361.     {
  362.         return strtolower(trim(preg_replace('/[^A-Za-z0-9-]+/', '-', $name)));
  363.     }
  365.     public function __call($method, $arguments)
  366.     {
  367.         return $this->proxyCurrentLocaleTranslation($method, $arguments);
  368.     }
  369.     public function __construct()
  370.     {
  371.         $this->categories          = new ArrayCollection();
  372.         $this->subcategories       = new ArrayCollection();
  373.         $this->productImages       = new ArrayCollection();
  374.         $this->productVideos       = new ArrayCollection();
  375.         $this->labels              = new ArrayCollection();
  376.         $this->priceScales         = new ArrayCollection();
  377.         $this->orderDetails        = new ArrayCollection();
  378.         $this->influencerShareds   = new ArrayCollection();
  379.         $this->userFavourites      = new ArrayCollection();
  380.         $this->fakeTriweersInOffer = new ArrayCollection();
  381.         $this->userReviews         = new ArrayCollection();
  382.     }
  384.     public function __clone()
  385.     {
  386.         $this->orderDetails      = new ArrayCollection();
  387.         $this->influencerShareds = new ArrayCollection();
  388.         $this->userFavourites    = new ArrayCollection();
  389.         $this->userReviews       = new ArrayCollection();
  391.         if ($this->id) {
  392.             $this->setId(null);
  393.         }
  395.         if ($this->holdedId) {
  396.             $this->setHoldedId('');
  397.         }
  399.         $this->setIsDraft(true);
  401.         foreach ($this->getTranslations() as $trans) {
  402.             /** @var \App\Entity\ProductTranslation $trans */
  403.             $clonedTrans = clone $trans;
  404.             $clonedTrans->setName('Clon ' . $clonedTrans->getName());
  405.             $this->addTranslation($clonedTrans);
  406.         }
  408.         foreach ($this->getProductImages() as $idx => $media) {
  409.             $this->addProductImage((new Media())->clone($media, 'product', $idx));
  410.         }
  412.         foreach ($this->getProductVideos() as $idx => $media) {
  413.             $this->addProductVideo((new Media())->clone($media, 'product', $idx));
  414.         }
  416.         foreach ($this->getPriceScales() as $idx => $scale) {
  417.             $this->addPriceScale(clone $scale);
  418.         }
  419.     }
  421.     public function setId(?int $id): self
  422.     {
  423.         $this->id = $id;
  425.         return $this;
  426.     }
  428.     public function getId(): ?int
  429.     {
  430.         return $this->id;
  431.     }
  433.     public function getSlug(): ?string
  434.     {
  435.         return $this->slug;
  436.     }
  438.     public function setSlug(string $slug): self
  439.     {
  440.         $this->slug = $slug;
  442.         return $this;
  443.     }
  445.     public function getStatus(): string
  446.     {
  447.         if ($this->isDraft) {
  448.             return Product::STATUS_DRAFT;
  449.         } else if ($this->isBlocked) {
  450.             return Product::STATUS_BLOCKED;
  451.         } else if ($this->isSoldOut || $this->endOfferDate < (new \DateTime())) {
  452.             return Product::STATUS_FINISHED;
  453.         } else if ($this->offerLaunchDate > (new \DateTime())) {
  454.             return Product::STATUS_SCHEDULED;
  455.         }
  457.         return Product::STATUS_ACTIVE;
  458.     }
  460.     public function getIsScheduled(): bool
  461.     {
  462.         return $this->getStatus() == Product::STATUS_SCHEDULED;
  463.     }
  464.     public function getIsActive(): bool
  465.     {
  466.         return $this->getStatus() == Product::STATUS_ACTIVE;
  467.     }
  468.     public function getIsFinished(): bool
  469.     {
  470.         return $this->getStatus() == Product::STATUS_FINISHED;
  471.     }
  473.     public function getIsFinishedPlusExtra(): bool
  474.     {
  475.         if ($this->getStatus() != Product::STATUS_FINISHED) {
  476.             return false;
  477.         }
  479.         if ($this->nHoursOnWallAfterEnd > 0) {
  480.             $endOfferDate = DateTime::createFromInterface($this->endOfferDate);
  481.             $endOfferDate->add(new DateInterval("PT{$this->nHoursOnWallAfterEnd}H"));
  483.             return $endOfferDate <= (new \DateTime());
  484.         }
  486.         return true;
  487.     }
  489.     public function getStatusBgColor(): string
  490.     {
  491.         $status = $this->getStatus();
  492.         switch ($status) {
  493.             case Product::STATUS_DRAFT:
  494.                 $color = "#F1C14F";
  495.                 break;
  496.             case Product::STATUS_BLOCKED:
  497.                 $color = "#000000";
  498.                 break;
  499.             case Product::STATUS_SCHEDULED:
  500.                 $color = "#36A9E1";
  501.                 break;
  502.             case Product::STATUS_ACTIVE:
  503.                 $color = "#32D29D";
  504.                 break;
  505.             case Product::STATUS_FINISHED:
  506.                 $color = "#FF4863";
  507.                 break;
  508.         }
  510.         return $color;
  511.     }
  512.     public function getStatusColor(): string
  513.     {
  514.         $status = $this->getStatus();
  515.         switch ($status) {
  516.             case Product::STATUS_DRAFT:
  517.                 $color = "#FFFFFF";
  518.                 break;
  519.             case Product::STATUS_BLOCKED:
  520.                 $color = "#FFFFFF";
  521.                 break;
  522.             case Product::STATUS_SCHEDULED:
  523.                 $color = "#FFFFFF";
  524.                 break;
  525.             case Product::STATUS_ACTIVE:
  526.                 $color = "#FFFFFF";
  527.                 break;
  528.             case Product::STATUS_FINISHED:
  529.                 $color = "#FFFFFF";
  530.                 break;
  531.         }
  533.         return $color;
  534.     }
  536.     public function getNameWithId(): ?string
  537.     {
  538.         return $this->getId() . ' - ' . $this->getName();
  539.     }
  541.     public function getType(): ?ProductType
  542.     {
  543.         return $this->type;
  544.     }
  546.     public function setType(?ProductType $type): self
  547.     {
  548.         $this->type = $type;
  550.         return $this;
  551.     }
  553.     public function getIsDraft(): ?bool
  554.     {
  555.         return $this->isDraft;
  556.     }
  558.     public function setIsDraft(?bool $isDraft): self
  559.     {
  560.         $this->isDraft = $isDraft;
  562.         return $this;
  563.     }
  565.     public function getIsBlocked(): ?bool
  566.     {
  567.         return $this->isBlocked;
  568.     }
  570.     public function setIsBlocked(?bool $isBlocked): self
  571.     {
  572.         $this->isBlocked = $isBlocked;
  574.         return $this;
  575.     }
  577.     public function getIsSoldOut(): ?bool
  578.     {
  579.         return $this->isSoldOut;
  580.     }
  582.     public function setIsSoldOut(bool $isSoldOut): self
  583.     {
  584.         $this->isSoldOut = $isSoldOut;
  586.         return $this;
  587.     }
  589.     public function getWeight(): ?float
  590.     {
  591.         return $this->weight;
  592.     }
  594.     public function setWeight(?float $weight): self
  595.     {
  596.         $this->weight = $weight;
  598.         return $this;
  599.     }
  601.     public function getWidth(): ?int
  602.     {
  603.         return $this->width;
  604.     }
  606.     public function setWidth(?int $width): self
  607.     {
  608.         $this->width = $width;
  610.         return $this;
  611.     }
  613.     public function getLength(): ?int
  614.     {
  615.         return $this->length;
  616.     }
  618.     public function setLength(?int $length): self
  619.     {
  620.         $this->length = $length;
  622.         return $this;
  623.     }
  625.     public function getHeight(): ?int
  626.     {
  627.         return $this->height;
  628.     }
  630.     public function setHeight(?int $height): self
  631.     {
  632.         $this->height = $height;
  634.         return $this;
  635.     }
  637.     public function getVolumetricWeight(): ?float
  638.     {
  639.         return $this->volumetricWeight;
  640.     }
  642.     public function setVolumetricWeight(?float $volumetricWeight): self
  643.     {
  644.         $this->volumetricWeight = $volumetricWeight;
  646.         return $this;
  647.     }
  649.     /**
  650.      *  Max value between weight and volumetric weight
  651.      */
  652.     public function getShippingWeight(): ?float
  653.     {
  654.         return max($this->volumetricWeight, $this->weight);
  655.     }
  657.     public function getEan(): ?string
  658.     {
  659.         return $this->ean;
  660.     }
  662.     public function setEan(?string $ean): self
  663.     {
  664.         $this->ean = $ean;
  666.         return $this;
  667.     }
  669.     public function getUnitsPerBox(): ?int
  670.     {
  671.         return $this->unitsPerBox;
  672.     }
  674.     public function setUnitsPerBox(?int $unitsPerBox): self
  675.     {
  676.         $this->unitsPerBox = $unitsPerBox;
  677.         return $this;
  678.     }
  680.     public function getUnitsPerBoxGrouped(): ?int
  681.     {
  682.         return $this->unitsPerBoxGrouped ?? 1;
  683.     }
  685.     public function setUnitsPerBoxGrouped(?int $unitsPerBoxGrouped): self
  686.     {
  687.         $this->unitsPerBoxGrouped = $unitsPerBoxGrouped;
  688.         return $this;
  689.     }
  691.     public function getHideDiscount(): ?bool
  692.     {
  693.         return $this->hideDiscount ?? false;
  694.     }
  696.     public function setHideDiscount(?bool $hideDiscount): self
  697.     {
  698.         $this->hideDiscount = $hideDiscount;
  699.         return $this;
  700.     }
  702.     /**
  703.      * @return Collection<int, Category>
  704.      */
  705.     public function getCategories(): Collection
  706.     {
  707.         return $this->categories;
  708.     }
  710.     public function getCategoriesText(): ?string
  711.     {
  712.         return implode(', ', $this->categories->toArray());
  713.     }
  716.     public function addCategory(Category $category): self
  717.     {
  718.         if (!$this->categories->contains($category)) {
  719.             $this->categories->add($category);
  720.         }
  722.         return $this;
  723.     }
  725.     public function removeCategory(Category $category): self
  726.     {
  727.         $this->categories->removeElement($category);
  729.         return $this;
  730.     }
  731.     /**
  732.      * @return Collection<int, Subcategory>
  733.      */
  734.     public function getSubcategories(): Collection
  735.     {
  736.         return $this->subcategories;
  737.     }
  739.     public function getSubcategoriesText(): ?string
  740.     {
  741.         return implode(', ', $this->subcategories->toArray());
  742.     }
  745.     public function addSubcategory(Subcategory $subcategory): self
  746.     {
  747.         if (!$this->subcategories->contains($subcategory)) {
  748.             $this->subcategories->add($subcategory);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeSubcategory(Subcategory $subcategory): self
  755.     {
  756.         $this->subcategories->removeElement($subcategory);
  758.         return $this;
  759.     }
  761.     public function getPurchaseOrderNumber(): ?string
  762.     {
  763.         return $this->purchaseOrderNumber;
  764.     }
  766.     public function setPurchaseOrderNumber(?string $purchaseOrderNumber): self
  767.     {
  768.         $this->purchaseOrderNumber = $purchaseOrderNumber;
  770.         return $this;
  771.     }
  773.     /**
  774.      * Main image is the one that have position 0
  775.      * @return Media|null
  776.      */
  777.     public function getMainProductImage(): ?Media
  778.     {
  779.         if ($this->productImages) {
  780.             $filteredProductImages = $this->productImages->filter(function (Media $productImage) {
  781.                 return $productImage->getPosition() == 0;
  782.             });
  784.             return (count($filteredProductImages) > 0) ? $filteredProductImages->first() : null;
  785.         } else {
  786.             return null;
  787.         }
  788.     }
  790.     /**
  791.      * @return Collection<int, Media>
  792.      */
  793.     public function getProductImages(): Collection
  794.     {
  795.         return $this->productImages;
  796.     }
  798.     public function addProductImage(Media $productImage): self
  799.     {
  800.         if (!$this->productImages->contains($productImage)) {
  801.             $productImage->setDirectory('product');
  803.             $this->productImages->add($productImage);
  804.             $productImage->setProductImage($this);
  805.         }
  807.         return $this;
  808.     }
  810.     public function removeProductImage(Media $productImage): self
  811.     {
  812.         if ($this->productImages->removeElement($productImage)) {
  813.             // set the owning side to null (unless already changed)
  814.             if ($productImage->getProductImage() === $this) {
  815.                 $productImage->setProductImage(null);
  816.             }
  817.         }
  819.         return $this;
  820.     }
  822.     /**
  823.      * @return Collection<int, Media>
  824.      */
  825.     public function getProductVideos(): Collection
  826.     {
  827.         return $this->productVideos;
  828.     }
  830.     public function addProductVideo(Media $productVideo): self
  831.     {
  832.         if (!$this->productVideos->contains($productVideo)) {
  833.             $productVideo->setDirectory('product');
  835.             $this->productVideos->add($productVideo);
  836.             $productVideo->setProductVideo($this);
  837.         }
  839.         return $this;
  840.     }
  842.     public function removeProductVideo(Media $productVideo): self
  843.     {
  844.         if ($this->productVideos->removeElement($productVideo)) {
  845.             // set the owning side to null (unless already changed)
  846.             if ($productVideo->getProductVideo() === $this) {
  847.                 $productVideo->setProductVideo(null);
  848.             }
  849.         }
  851.         return $this;
  852.     }
  854.     /**
  855.      * @return Collection<int, Label>
  856.      */
  857.     public function getLabels(): Collection
  858.     {
  859.         return $this->labels;
  860.     }
  862.     public function getLabelsText(): ?string
  863.     {
  864.         return implode(', ', $this->labels->toArray());
  865.     }
  867.     public function addLabel(Label $label): self
  868.     {
  869.         if (!$this->labels->contains($label)) {
  870.             $this->labels->add($label);
  871.         }
  873.         return $this;
  874.     }
  876.     public function removeLabel(Label $label): self
  877.     {
  878.         $this->labels->removeElement($label);
  880.         return $this;
  881.     }
  883.     public function getIsMandatoryProductFeatures(): ?bool
  884.     {
  885.         return $this->isMandatoryProductFeatures;
  886.     }
  888.     public function setIsMandatoryProductFeatures(bool $isMandatoryProductFeatures): self
  889.     {
  890.         $this->isMandatoryProductFeatures = $isMandatoryProductFeatures;
  892.         return $this;
  893.     }
  895.     public function getIsMandatoryProducer(): ?bool
  896.     {
  897.         return $this->isMandatoryProducer;
  898.     }
  900.     public function setIsMandatoryProducer(bool $isMandatoryProducer): self
  901.     {
  902.         $this->isMandatoryProducer = $isMandatoryProducer;
  904.         return $this;
  905.     }
  907.     public function getIsMandatoryTriweerList(): ?bool
  908.     {
  909.         return $this->isMandatoryTriweerList;
  910.     }
  912.     public function setIsMandatoryTriweerList(?bool $isMandatoryTriweerList): self
  913.     {
  914.         $this->isMandatoryTriweerList = $isMandatoryTriweerList;
  916.         return $this;
  917.     }
  919.     public function getIsMandatoryTriweerComments(): ?bool
  920.     {
  921.         return $this->isMandatoryTriweerComments;
  922.     }
  924.     public function setIsMandatoryTriweerComments(?bool $isMandatoryTriweerComments): self
  925.     {
  926.         $this->isMandatoryTriweerComments = $isMandatoryTriweerComments;
  928.         return $this;
  929.     }
  931.     public function isIsLiveShopping(): ?bool
  932.     {
  933.         return $this->isLiveShopping;
  934.     }
  936.     public function setIsLiveShopping(bool $isLiveShopping): self
  937.     {
  938.         $this->isLiveShopping = $isLiveShopping;
  940.         return $this;
  941.     }
  943.     public function isHasBlockchainTraceability(): ?bool
  944.     {
  945.         return $this->hasBlockchainTraceability;
  946.     }
  948.     public function setHasBlockchainTraceability(bool $hasBlockchainTraceability): self
  949.     {
  950.         $this->hasBlockchainTraceability = $hasBlockchainTraceability;
  952.         return $this;
  953.     }
  955.     public function getShowOnWall(): ?bool
  956.     {
  957.         return $this->showOnWall;
  958.     }
  960.     public function setShowOnWall(bool $showOnWall): self
  961.     {
  962.         $this->showOnWall = $showOnWall;
  964.         return $this;
  965.     }
  967.     public function getAllowReturn(): ?bool
  968.     {
  969.         return $this->allowReturn;
  970.     }
  972.     public function setAllowReturn(bool $allowReturn): self
  973.     {
  974.         $this->allowReturn = $allowReturn;
  976.         return $this;
  977.     }
  979.     public function getNDaysAllowedForReturn(): ?int
  980.     {
  981.         return $this->nDaysAllowedForReturn;
  982.     }
  984.     public function setNDaysAllowedForReturn(?int $nDaysAllowedForReturn): self
  985.     {
  986.         $this->nDaysAllowedForReturn = $nDaysAllowedForReturn;
  988.         return $this;
  989.     }
  991.     public function isInWarrantyPeriod(DateTime $dateBought): ?bool
  992.     {
  993.         $now = new DateTime('now');
  994.         if ($this->getAllowReturn() && $this->getNDaysAllowedForReturn()) {
  995.             $dayToCompare = $dateBought->add(new DateInterval('P' . $this->getNDaysAllowedForReturn() . 'D'));
  996.             if ($now > $dateBought) {
  997.                 return true;
  998.             } else {
  999.                 return false;
  1000.             }
  1001.         } else {
  1002.             return false;
  1003.         }
  1004.     }
  1007.     public function isSendNotifications(): ?bool
  1008.     {
  1009.         return $this->sendNotifications;
  1010.     }
  1012.     public function setSendNotifications(bool $sendNotifications): self
  1013.     {
  1014.         $this->sendNotifications = $sendNotifications;
  1016.         return $this;
  1017.     }
  1019.     public function getProducerPurchaseOrderNumber(): ?string
  1020.     {
  1021.         return $this->producerPurchaseOrderNumber;
  1022.     }
  1024.     public function setProducerPurchaseOrderNumber(?string $producerPurchaseOrderNumber): self
  1025.     {
  1026.         $this->producerPurchaseOrderNumber = $producerPurchaseOrderNumber;
  1028.         return $this;
  1029.     }
  1031.     public function getLimitUnitsPerBuyer(): ?int
  1032.     {
  1033.         return $this->limitUnitsPerBuyer;
  1034.     }
  1036.     public function setLimitUnitsPerBuyer(int $limitUnitsPerBuyer): self
  1037.     {
  1038.         $this->limitUnitsPerBuyer = $limitUnitsPerBuyer;
  1040.         return $this;
  1041.     }
  1043.     public function getLimitUnitsToSell(): ?int
  1044.     {
  1045.         return $this->limitUnitsToSell;
  1046.     }
  1048.     public function setLimitUnitsToSell(?int $limitUnitsToSell): self
  1049.     {
  1050.         $this->limitUnitsToSell = $limitUnitsToSell;
  1052.         return $this;
  1053.     }
  1055.     public function getComingSoonDate(): ?\DateTimeInterface
  1056.     {
  1057.         return $this->comingSoonDate;
  1058.     }
  1060.     public function setComingSoonDate(?\DateTimeInterface $comingSoonDate): self
  1061.     {
  1062.         $this->comingSoonDate = $comingSoonDate;
  1064.         return $this;
  1065.     }
  1067.     public function getOfferLaunchDate(): ?\DateTimeInterface
  1068.     {
  1069.         return $this->offerLaunchDate;
  1070.     }
  1072.     public function setOfferLaunchDate(?\DateTimeInterface $offerLaunchDate): self
  1073.     {
  1074.         $this->offerLaunchDate = $offerLaunchDate;
  1076.         return $this;
  1077.     }
  1079.     /**
  1080.      * Indicates if it should show the countdown in templates
  1081.      *
  1082.      * @return boolean
  1083.      */
  1084.     public function getShowCountdown(): bool
  1085.     {
  1086.         if ($this->countdownDate && $this->countdownDate < (new \DateTime())) {
  1087.             return true;
  1088.         }
  1089.         return false;
  1090.     }
  1092.     public function getCountdownDate(): ?\DateTimeInterface
  1093.     {
  1094.         return $this->countdownDate;
  1095.     }
  1097.     public function setCountdownDate(?\DateTimeInterface $countdownDate): self
  1098.     {
  1099.         $this->countdownDate = $countdownDate;
  1101.         return $this;
  1102.     }
  1104.     public function getEndOfferDate(): ?\DateTimeInterface
  1105.     {
  1106.         return $this->endOfferDate;
  1107.     }
  1109.     public function setEndOfferDate(?\DateTimeInterface $endOfferDate): self
  1110.     {
  1111.         $this->endOfferDate = $endOfferDate;
  1113.         return $this;
  1114.     }
  1116.     public function getShippingDate(): ?\DateTimeInterface
  1117.     {
  1118.         return $this->shippingDate;
  1119.     }
  1121.     public function setShippingDate(?\DateTimeInterface $shippingDate): self
  1122.     {
  1123.         $this->shippingDate = $shippingDate;
  1125.         return $this;
  1126.     }
  1128.     public function getIndividualShippingDuration(): ?int
  1129.     {
  1130.         return $this->individualShippingDuration ?? Product::DEFAULT_SHIPPING_INDIVIDUAL_DURANTION;
  1131.     }
  1133.     public function setIndividualShippingDuration(?int $individualShippingDuration): self
  1134.     {
  1135.         $this->individualShippingDuration = $individualShippingDuration;
  1137.         return $this;
  1138.     }
  1140.     public function getSharedShippingDuration(): ?int
  1141.     {
  1142.         return $this->sharedShippingDuration ?? Product::DEFAULT_SHIPPING_SHARED_DURANTION;
  1143.     }
  1145.     public function setSharedShippingDuration(?int $sharedShippingDuration): self
  1146.     {
  1147.         $this->sharedShippingDuration = $sharedShippingDuration;
  1149.         return $this;
  1150.     }
  1152.     public function getIndividualPackageFormat(): ?string
  1153.     {
  1154.         return $this->individualPackageFormat;
  1155.     }
  1157.     public function setIndividualPackageFormat(?string $individualPackageFormat): self
  1158.     {
  1159.         $this->individualPackageFormat = $individualPackageFormat;
  1161.         return $this;
  1162.     }
  1164.     public function getNHoursOnWallAfterEnd(): ?int
  1165.     {
  1166.         return $this->nHoursOnWallAfterEnd;
  1167.     }
  1169.     public function setNHoursOnWallAfterEnd(int $nHoursOnWallAfterEnd): self
  1170.     {
  1171.         $this->nHoursOnWallAfterEnd = $nHoursOnWallAfterEnd;
  1173.         return $this;
  1174.     }
  1176.     public function getIva(): ?Iva
  1177.     {
  1178.         return $this->iva;
  1179.     }
  1181.     public function setIva(?Iva $iva): self
  1182.     {
  1183.         $this->iva = $iva;
  1185.         return $this;
  1186.     }
  1188.     public function getIndividualPrice(): ?float
  1189.     {
  1190.         return $this->individualPrice ?? $this->getInitialPrice();
  1191.     }
  1193.     public function setIndividualPrice(?float $individualPrice): self
  1194.     {
  1195.         $this->individualPrice = $individualPrice;
  1197.         return $this;
  1198.     }
  1200.     public function getIndividualDisabled(): ?bool
  1201.     {
  1202.         return $this->individualDisabled ?? $this->getInitialPrice();
  1203.     }
  1205.     public function setIndividualDisabled(?bool $individualDisabled): self
  1206.     {
  1207.         $this->individualDisabled = $individualDisabled;
  1209.         return $this;
  1210.     }
  1212.     public function getInitialPrice(): ?float
  1213.     {
  1214.         if ($this->priceScales->count() === 0) {
  1215.             return $this->originalPrice;
  1216.         }
  1218.         return $this->priceScales[0]->getInitialPrice();
  1219.     }
  1221.     public function getCurrentPrice(): float
  1222.     {
  1223.         $currentQuantityOrdered = $this->getCurrentQuantityOrdered();
  1224.         $currentPriceScale = $this->getCurrentPriceScale($currentQuantityOrdered);
  1226.         if ($currentPriceScale->isSellProductIfNotComplete()) {
  1227.             if ($currentQuantityOrdered  < $currentPriceScale->getTotalMaxQuantity()) {
  1228.                 return $currentPriceScale->getInitialPrice();
  1229.             } else {
  1230.                 return $currentPriceScale->getFinalPrice();
  1231.             }
  1232.         } else {
  1233.             return $this->getNextPrice();
  1234.         }
  1235.     }
  1237.     public function getNextPrice(?int $cartQuantity = 0): float
  1238.     {
  1239.         $currentQuantityOrdered = $this->getCurrentQuantityOrdered();
  1240.         $currentPriceScale      = $this->getCurrentPriceScale($currentQuantityOrdered);
  1242.         // if (($this->priceScales->count() === 1) or ($this->currentScaleIsFirst($currentPriceScale))) {
  1243.         //     if ($currentPriceScale->isSellProductIfNotComplete()) {
  1244.         //         return $currentPriceScale->getInitialPrice();
  1245.         //     }else{
  1246.         //         return $currentPriceScale->getFinalPrice();
  1247.         //     }
  1248.         // }
  1250.         if ($currentPriceScale->isSellProductIfNotComplete()) {
  1251.             $belowMinQty = ($currentQuantityOrdered + $cartQuantity) < $this->getScalesAccumulatedMinQuantity();
  1252.             return $belowMinQty
  1253.                 ? $currentPriceScale->getInitialPrice()
  1254.                 : $currentPriceScale->getFinalPrice();
  1255.         } else {
  1256.             return $currentPriceScale->getFinalPrice();
  1257.         }
  1258.     }
  1260.     /**
  1261.      * Get the accumulated minimum quantity for multiple price scales.
  1262.      */
  1263.     public function getScalesAccumulatedMinQuantity(): int
  1264.     {
  1265.         $currentQuantityOrdered = $this->getCurrentQuantityOrdered();
  1266.         $currentPriceScale      = $this->getCurrentPriceScale($currentQuantityOrdered);
  1268.         return $this->getPriceScales()->reduce(
  1269.             fn ($acc, $scale) =>
  1270.             $currentPriceScale->getFinalPrice() <= $scale->getFinalPrice()
  1271.                 ? $acc + $scale->getScaleQuantity()
  1272.                 : $acc
  1273.         );
  1274.     }
  1276.     /**
  1277.      * Get the goal of orders (sum. of all scales units)
  1278.      *
  1279.      * @return float|null
  1280.      */
  1281.     public function getScaleOrdersGoal(): ?float
  1282.     {
  1283.         return $this->getPriceScales()->reduce(
  1284.             fn ($acc, $scale) => $acc + $scale->getScaleQuantity()
  1285.         );
  1286.     }
  1288.     /**
  1289.      * Get the current quantity of orders (sum. of all scales units until the current one)
  1290.      *
  1291.      * @return float|null
  1292.      */
  1293.     public function getScaleOrdersCurrent(): ?float
  1294.     {
  1295.         $current = $this->getCurrentPriceScale();
  1296.         return $this->getPriceScales()->reduce(
  1297.             function ($acc, $scale) use ($current) {
  1298.                 if ($current->getFinalPrice() <= $scale->getFinalPrice()) {
  1299.                     $acc += $scale->getScaleQuantity();
  1300.                 }
  1301.                 return $acc;
  1302.             }
  1303.         );
  1304.     }
  1306.     /**
  1307.      * Check if the current price scale is the first one.
  1308.      */
  1309.     public function currentScaleIsFirst($currentPriceScale): bool
  1310.     {
  1311.         return $this->priceScales->first()->getId() === $currentPriceScale->getId();
  1312.     }
  1314.     /**
  1315.      * Get the current price scale. It depends on the quantity already ordered
  1316.      *
  1317.      * @return ProductPriceScale
  1318.      */
  1319.     public function getCurrentPriceScale($currentQuantityOrdered = null): ProductPriceScale
  1320.     {
  1322.         if ($currentQuantityOrdered === null) {
  1323.             $currentQuantityOrdered = $this->getCurrentQuantityOrdered();
  1324.         }
  1326.         $currentPriceScale = null;
  1327.         /** @var ProductPriceScale */
  1328.         foreach ($this->priceScales as $priceScale) {
  1329.             if (
  1330.                 ($priceScale->getTotalMinQuantity() <= $currentQuantityOrdered) &&
  1331.                 ($currentQuantityOrdered < $priceScale->getTotalMaxQuantity())
  1332.             ) {
  1333.                 $currentPriceScale = $priceScale;
  1334.                 break;
  1335.             }
  1336.         }
  1337.         if (!$currentPriceScale) {
  1338.             $currentPriceScale = $priceScale;
  1339.         }
  1341.         return $currentPriceScale;
  1342.     }
  1344.     /**
  1345.      * @return boolean
  1346.      */
  1347.     public function getIsSellIsEnought()
  1348.     {
  1349.         return $this->getCurrentPriceScale()->isSellProductIfNotComplete();
  1350.     }
  1351.     /**
  1352.      * Get the current price scale. It depends on the quantity already ordered
  1353.      *
  1354.      * @return ProductPriceScale
  1355.      */
  1356.     public function getNextPriceScale($currentQuantityOrdered = null): ProductPriceScale
  1357.     {
  1358.         if ($currentQuantityOrdered === null) {
  1359.             $currentQuantityOrdered = $this->getCurrentQuantityOrdered();
  1360.         }
  1362.         $currentPriceScale = null;
  1363.         $next = False;
  1364.         $nextPriceScale = null;
  1365.         /** @var ProductPriceScale */
  1366.         foreach ($this->priceScales as $priceScale) {
  1367.             if ($next) {
  1368.                 $nextPriceScale = $priceScale;
  1369.                 $next = False;
  1370.             }
  1371.             if (
  1372.                 ($priceScale->getTotalMinQuantity() <= $currentQuantityOrdered) &&
  1373.                 ($currentQuantityOrdered < $priceScale->getTotalMaxQuantity())
  1374.             ) {
  1375.                 $next = true;
  1376.                 $currentPriceScale = $priceScale;
  1377.             }
  1378.         }
  1379.         if (!$currentPriceScale) {
  1380.             $currentPriceScale = $priceScale;
  1381.         }
  1382.         if (!$nextPriceScale) {
  1383.             $nextPriceScale = $currentPriceScale;
  1384.         }
  1385.         return $nextPriceScale;
  1386.     }
  1389.     /**
  1390.      * Max product quantity
  1391.      *
  1392.      * @return integer
  1393.      */
  1394.     public function getProductMaxQuantity(): int
  1395.     {
  1396.         $totalQuantity = 0;
  1397.         if ($this->priceScales) {
  1398.             /** @var ProductPriceScale */
  1399.             foreach ($this->priceScales as $priceScale) {
  1400.                 $totalQuantity += $priceScale->getScaleQuantity();
  1401.             }
  1402.         }
  1404.         return $totalQuantity;
  1405.     }
  1407.     /**
  1408.      * Max product quantity
  1409.      *
  1410.      * @return integer
  1411.      */
  1412.     public function getProductMaxQuantityAvailable(): int
  1413.     {
  1414.         $totalQuantity = 0;
  1415.         if ($this->priceScales) {
  1416.             /** @var ProductPriceScale */
  1417.             foreach ($this->priceScales as $priceScale) {
  1418.                 $totalQuantity += $priceScale->getScaleQuantityAvailable();
  1419.             }
  1420.         }
  1422.         return $totalQuantity;
  1423.     }
  1425.     /**
  1426.      * @return ProductPriceScale
  1427.      */
  1428.     public function getInitialPriceScale(): ProductPriceScale
  1429.     {
  1430.         return $this->priceScales->first();
  1431.     }
  1433.     /**
  1434.      * @return ProductPriceScale
  1435.      */
  1436.     public function getLastPriceScale(): ProductPriceScale
  1437.     {
  1438.         return $this->priceScales->last();
  1439.     }
  1441.     public function getOrderedPriceScales(): Collection
  1442.     {
  1443.         $criteria = Criteria::create()
  1444.             ->orderBy(['scaleQuantity' => Criteria::ASC]);
  1445.         $orderedPrices = $this->priceScales->matching($criteria);
  1446.         return $orderedPrices;
  1447.     }
  1449.     /**
  1450.      * @return Collection<int, ProductPriceScale>
  1451.      */
  1452.     public function getPriceScales(): Collection
  1453.     {
  1454.         return $this->priceScales;
  1455.     }
  1457.     public function addPriceScale(ProductPriceScale $priceScale): self
  1458.     {
  1459.         if (!$this->priceScales->contains($priceScale)) {
  1460.             $this->priceScales->add($priceScale);
  1461.             $priceScale->setProduct($this);
  1462.         }
  1464.         return $this;
  1465.     }
  1467.     public function removePriceScale(ProductPriceScale $priceScale): self
  1468.     {
  1469.         if ($this->priceScales->removeElement($priceScale)) {
  1470.             // set the owning side to null (unless already changed)
  1471.             if ($priceScale->getProduct() === $this) {
  1472.                 $priceScale->setProduct(null);
  1473.             }
  1474.         }
  1476.         return $this;
  1477.     }
  1479.     public function getMaxCoinsToSpent(): ?int
  1480.     {
  1481.         return $this->maxCoinsToSpent;
  1482.     }
  1484.     public function setMaxCoinsToSpent(int $maxCoinsToSpent): self
  1485.     {
  1486.         $this->maxCoinsToSpent = $maxCoinsToSpent;
  1488.         return $this;
  1489.     }
  1491.     public function getBrand(): ?Brand
  1492.     {
  1493.         return $this->brand;
  1494.     }
  1496.     public function setBrand(?Brand $brand): self
  1497.     {
  1498.         $this->brand = $brand;
  1500.         return $this;
  1501.     }
  1503.     public function getProducer(): ?Producer
  1504.     {
  1505.         return $this->producer;
  1506.     }
  1508.     public function setProducer(?Producer $producer): self
  1509.     {
  1510.         $this->producer = $producer;
  1512.         return $this;
  1513.     }
  1515.     public function getUnitMeasurement(): ?UnitMeasurement
  1516.     {
  1517.         return $this->unitMeasurement;
  1518.     }
  1520.     public function setUnitMeasurement(?UnitMeasurement $unitMeasurement): self
  1521.     {
  1522.         $this->unitMeasurement = $unitMeasurement;
  1524.         return $this;
  1525.     }
  1527.     /**
  1528.      * Get the current products's quantity ordered
  1529.      * @return int
  1530.      */
  1531.     public function getCurrentQuantityOrdered(): int
  1532.     {
  1533.         $currentQuantityOrdered = $this->fakeUsers ? $this->fakeUsers : 0;
  1534.         /** @var OrderDetail */
  1535.         foreach ($this->orderDetails as $orderDetail) {
  1536.             if (
  1537.                 $orderDetail->getHeader()->getStatus()->getKey() == OrderStatus::PENDING_PAYMENT ||
  1538.                 $orderDetail->getHeader()->getStatus()->getKey() == OrderStatus::CANCELED
  1539.             ) {
  1540.                 continue;
  1541.             }
  1542.             $currentQuantityOrdered += $orderDetail->getQuantity();
  1543.         }
  1544.         return $currentQuantityOrdered;
  1545.     }
  1547.     /**
  1548.      * Get the current products's quantity ordered
  1549.      * @return bool
  1550.      */
  1551.     public function hasBeenPurchasedRecently(?int $orderID = null): bool
  1552.     {
  1553.         /** @var OrderDetail */
  1554.         foreach ($this->orderDetails as $orderDetail) {
  1555.             $order = $orderDetail->getHeader();
  1556.             if ($orderID && $order->getId() === $orderID) continue;
  1557.             if ($order->getStatus()->getKey() == OrderStatus::MONEY_WITHHELD) {
  1558.                 return true;
  1559.             }
  1560.         }
  1562.         return false;
  1563.     }
  1565.     /**
  1566.      * Get the current products's quantity ordered in percentage
  1567.      * @return float
  1568.      */
  1569.     public function getCurrentOrderedPercentage(): float
  1570.     {
  1571.         $productMaxQuantity = $this->getProductMaxQuantity();
  1572.         if ($productMaxQuantity) {
  1573.             return (100 * $this->getCurrentQuantityOrdered() / $productMaxQuantity);
  1574.         } else {
  1575.             return 0;
  1576.         }
  1577.     }
  1579.     /**
  1580.      * @return Collection<int, OrderDetail>
  1581.      */
  1582.     public function getOrderDetails(): Collection
  1583.     {
  1584.         return $this->orderDetails;
  1585.     }
  1587.     public function addOrderDetail(OrderDetail $orderDetail): self
  1588.     {
  1589.         if (!$this->orderDetails->contains($orderDetail)) {
  1590.             $this->orderDetails->add($orderDetail);
  1591.             $orderDetail->setProduct($this);
  1592.         }
  1594.         return $this;
  1595.     }
  1597.     public function removeOrderDetail(OrderDetail $orderDetail): self
  1598.     {
  1599.         if ($this->orderDetails->removeElement($orderDetail)) {
  1600.             // set the owning side to null (unless already changed)
  1601.             if ($orderDetail->getProduct() === $this) {
  1602.                 $orderDetail->setProduct(null);
  1603.             }
  1604.         }
  1606.         return $this;
  1607.     }
  1609.     public function getPendingOrderDetails(): Collection
  1610.     {
  1611.         return $this->getOrderDetails()->filter(function($i) {
  1612.             $validStatus = !in_array($i->getHeader()->getStatus()->getKey(), [OrderStatus::PENDING_PAYMENT, OrderStatus::CANCELED, OrderStatus::NOT_SOLD]);
  1613.             $validDate   = $i->getCreatedAt() > $this->getOfferLaunchDate();
  1614.             
  1615.             return $validStatus && $validDate;
  1616.         });
  1617.     }
  1619.     public function getPendingOrderDetailsQuantity(): int
  1620.     {
  1621.         return $this->getOrderDetails()->reduce(function($acc, $item) {
  1622.             if (in_array($item->getHeader()->getStatus()->getKey(), [OrderStatus::MONEY_WITHHELD, OrderStatus::BANK_TRANSFER])) {
  1623.                 $acc += $item->getQuantity();
  1624.             }
  1625.             return $acc;
  1626.         }, 0);
  1627.     }
  1629.     public function getNumberOfOrders(): ?int
  1630.     {
  1631.         $ordersById = [];
  1632.         /** @var OrderDetail */
  1633.         foreach ($this->orderDetails as $orderDetail) {
  1634.             if (
  1635.                 $orderDetail->getHeader()->getStatus()->getKey() == OrderStatus::PENDING_PAYMENT ||
  1636.                 $orderDetail->getHeader()->getStatus()->getKey() == OrderStatus::CANCELED ||
  1637.                 $orderDetail->getHeader()->getStatus()->getKey() == OrderStatus::NOT_SOLD
  1638.             ) {
  1639.                 continue;
  1640.             }
  1641.             array_push($ordersById, [$orderDetail->getHeader()->getId() => $orderDetail]);
  1642.         }
  1644.         return count($ordersById);
  1645.     }
  1647.     public function getOriginalPrice(): ?float
  1648.     {
  1649.         return $this->originalPrice;
  1650.     }
  1652.     public function setOriginalPrice(?float $originalPrice): self
  1653.     {
  1654.         $this->originalPrice = $originalPrice;
  1656.         return $this;
  1657.     }
  1659.     public function getFakeUsers(): ?int
  1660.     {
  1661.         return $this->fakeUsers;
  1662.     }
  1664.     public function setFakeUsers(?int $fakeUsers): self
  1665.     {
  1666.         $this->fakeUsers = $fakeUsers;
  1668.         return $this;
  1669.     }
  1671.     /**
  1672.      * @return Collection<int, User>
  1673.      */
  1674.     public function getFakeTriweersInOffer(): Collection
  1675.     {
  1676.         return $this->fakeTriweersInOffer;
  1677.     }
  1679.     public function addFakeTriweersInOffer(User $user): self
  1680.     {
  1681.         if (!$this->fakeTriweersInOffer->contains($user)) {
  1682.             $this->fakeTriweersInOffer[] = $user;
  1683.         }
  1685.         return $this;
  1686.     }
  1688.     public function removeFakeTriweersInOffer(User $user): self
  1689.     {
  1690.         $this->fakeTriweersInOffer->removeElement($user);
  1692.         return $this;
  1693.     }
  1695.     /**
  1696.      * Calculate discount percentage dynamically based on field values
  1697.      *
  1698.      * @return float|null
  1699.      */
  1700.     public function getDiscountPercentage(): ?float 
  1701.     {
  1702.         if ($this->getUnitsPerBoxGrouped() > 0) {
  1703.             $originalUnitPrice = $this->originalPrice / ($this->getUnitsPerBox() ?? 1);
  1704.             $sharedUnitPrice = $this->getNextPrice() / $this->getUnitsPerBoxGrouped();
  1705.             return (100 - (100 * $sharedUnitPrice / $originalUnitPrice));
  1706.         }
  1707.         return (100 - (100 * $this->getNextPrice() / $this->originalPrice));
  1708.     }
  1710.     public function getCartSavings($hasGroup)
  1711.     {
  1712.         $finalPrice = $this->getNextPrice();
  1713.         $saving     = 0;
  1715.         if ($hasGroup) {
  1716.             $originalUnitPrice = $this->getOriginalPrice() / $this->getUnitsPerBoxGrouped();
  1717.             $unitPrice         = $finalPrice / $this->getUnitsPerBoxGrouped();
  1718.             $saving            = ($this->getUnitsPerBoxGrouped() > 0)
  1719.                 ? (100 - (100 * $unitPrice / $originalUnitPrice))
  1720.                 : (100 - (100 * $finalPrice / $this->getOriginalPrice()));
  1721.         } else {
  1722.             $originalUnitPrice = $this->getOriginalPrice() / $this->getUnitsPerBox();
  1723.             $unitPrice         = $finalPrice / $this->getUnitsPerBox();
  1724.             $saving            = ($this->getUnitsPerBox() > 0)
  1725.                  ? (100 - (100 * $unitPrice / $originalUnitPrice))
  1726.                  : (100 - (100 * $finalPrice / $this->getOriginalPrice()));
  1727.         }
  1729.         return $saving;
  1730.     }
  1732.     /**
  1733.      * Calculate max. discount percentage dynamically based on field values
  1734.      *
  1735.      * @return float|null
  1736.      */
  1737.     public function getMaxDiscountPercentage(): ?float
  1738.     {
  1739.         $lastScale = $this->getPriceScales()->last();
  1741.         $originalUnitPrice = $this->originalPrice / $this->getUnitsPerBox();
  1742.         $sharedUnitPrice = $lastScale->getFinalPrice() / ($this->getUnitsPerBoxGrouped() ?? 1);
  1743.         return (100 - (100 * $sharedUnitPrice / $originalUnitPrice));
  1744.     }
  1746.     /**
  1747.      * Calculate max. discount price dynamically based on field values
  1748.      *
  1749.      * @return float|null
  1750.      */
  1751.     public function getMaxDiscountUnitPrice(): ?float
  1752.     {
  1753.         $lastScale = $this->getPriceScales()->last();
  1754.         $sharedUnitPrice = $lastScale->getFinalPrice() / ($this->getUnitsPerBoxGrouped() ?? 1);
  1755.         return $sharedUnitPrice;
  1756.     }
  1758.     /**
  1759.      * Calculate discount percentage for collective purchase dynamically based on field values
  1760.      *
  1761.      * @return float|null
  1762.      */
  1763.     public function getIndividualDiscountPercentage(): ?float
  1764.     {
  1765.         return (100 - (100 * $this->getIndividualPrice() / $this->originalPrice));
  1766.     }
  1768.     public function getNextDiscountPercentage(): ?float
  1769.     {
  1770.         if (count($this->getPriceScales()) > 1) {
  1771.             return (100 - (100 * $this->getNextPrice() / $this->originalPrice));
  1772.         } else {
  1773.             // Return Discount relative to final price Scale if only 1 price
  1774.             // scale is defined. #316
  1775.             return (100 - (100 * $this->getLastPriceScale()->getFinalPrice() / $this->originalPrice));
  1776.         };
  1777.     }
  1779.     public function getShippingCost(): ?float
  1780.     {
  1781.         return $this->getShipping() ? $this->getShipping()->getCostByKgs($this->weight) : null;
  1782.     }
  1784.     public function setShippingCost(?float $shippingCost): self
  1785.     {
  1786.         $this->shippingCost = $shippingCost;
  1788.         return $this;
  1789.     }
  1791.     public function getHoldedId(): ?string
  1792.     {
  1793.         return $this->holdedId;
  1794.     }
  1796.     public function setHoldedId(?string $holdedId): self
  1797.     {
  1798.         $this->holdedId = $holdedId;
  1800.         return $this;
  1801.     }
  1803.     /**
  1804.      * @return Collection<int, UserShared>
  1805.      */
  1806.     public function getInfluencerShareds(): Collection
  1807.     {
  1808.         return $this->influencerShareds;
  1809.     }
  1811.     public function addInfluencerShared(UserShared $influencerShared): self
  1812.     {
  1813.         if (!$this->influencerShareds->contains($influencerShared)) {
  1814.             $this->influencerShareds->add($influencerShared);
  1815.             $influencerShared->setProduct($this);
  1816.         }
  1818.         return $this;
  1819.     }
  1821.     public function removeInfluencerShared(UserShared $influencerShared): self
  1822.     {
  1823.         if ($this->influencerShareds->removeElement($influencerShared)) {
  1824.             // set the owning side to null (unless already changed)
  1825.             if ($influencerShared->getProduct() === $this) {
  1826.                 $influencerShared->setProduct(null);
  1827.             }
  1828.         }
  1830.         return $this;
  1831.     }
  1833.     public function getProductUnique(): ?ProductUnique
  1834.     {
  1835.         return $this->productUnique;
  1836.     }
  1838.     public function setProductUnique(?ProductUnique $productUnique): self
  1839.     {
  1840.         $this->productUnique = $productUnique;
  1842.         return $this;
  1843.     }
  1845.     public function isOnlyAdults(): ?bool
  1846.     {
  1847.         return $this->onlyAdults;
  1848.     }
  1850.     public function setOnlyAdults(bool $onlyAdults): self
  1851.     {
  1852.         $this->onlyAdults = $onlyAdults;
  1854.         return $this;
  1855.     }
  1857.     public function getAmountForFreeShipping(): ?int
  1858.     {
  1859.         return $this->amountForFreeShipping;
  1860.     }
  1862.     public function setAmountForFreeShipping(?int $amountForFreeShipping): self
  1863.     {
  1864.         $this->amountForFreeShipping = $amountForFreeShipping;
  1866.         return $this;
  1867.     }
  1869.     public function isBetterPrice(): ?bool
  1870.     {
  1871.         return $this->better_price;
  1872.     }
  1874.     public function setBetterPrice(?bool $better_price): self
  1875.     {
  1876.         $this->better_price = $better_price;
  1878.         return $this;
  1879.     }
  1881.     public function getShipping(): ?Shipping
  1882.     {
  1883.         return $this->shipping;
  1884.     }
  1886.     public function setShipping(?Shipping $shipping): self
  1887.     {
  1888.         $this->shipping = $shipping;
  1890.         return $this;
  1891.     }
  1893.     /**
  1894.      * @return Collection<int, User>
  1895.      */
  1896.     public function getUserFavourites(): Collection
  1897.     {
  1898.         return $this->userFavourites;
  1899.     }
  1901.     /**
  1902.      * Shuffles the collection
  1903.      * 
  1904.      * @return Collection<int, User>
  1905.      */
  1906.     public function getRandomUserFavourites(): Collection
  1907.     {
  1908.         $array = $this->userFavourites->toArray();
  1909.         shuffle($array);
  1911.         return new ArrayCollection($array);
  1912.     }
  1914.     /**
  1915.      * @return Collection<int, Review>
  1916.      */
  1917.     public function getUserReviews(): Collection
  1918.     {
  1919.         return $this->userReviews;
  1920.     }
  1922.     public function getMetaTitle(): ?string
  1923.     {
  1924.         return $this->meta_title;
  1925.     }
  1927.     public function setMetaTitle(?string $meta_title): self
  1928.     {
  1929.         $this->meta_title = $meta_title;
  1931.         return $this;
  1932.     }
  1934.     public function getMetaDescription(): ?string
  1935.     {
  1936.         return $this->meta_description;
  1937.     }
  1939.     public function setMetaDescription(?string $meta_description): self
  1940.     {
  1941.         $this->meta_description = $meta_description;
  1943.         return $this;
  1944.     }
  1946.     public function isShowPrice(): ?bool
  1947.     {
  1948.         return $this->showPrice;
  1949.     }
  1951.     public function setShowPrice(?bool $showPrice): self
  1952.     {
  1953.         $this->showPrice = $showPrice;
  1955.         return $this;
  1956.     }
  1957. }