src/Entity/Product/ProductVariant.php line 410

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity\Product;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Sylius\Component\Core\Model\ProductVariant as BaseProductVariant;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\Common\Collections\Collection;
  12. use Webmozart\Assert\Assert;
  13. use Sylius\Component\Attribute\Model\AttributeValueInterface;
  15. use App\Entity\Order\OrderItem;
  17. class ProductVariant extends BaseProductVariant implements ProductVariantInterface
  18. {
  19.     
  20.     public const COATING_TYPE_VALUES = [
  21.         'coating_mat',
  22.         'coating_brillant',
  23.         'coating_inner',
  24.         'fabric_heat_sealed'
  25.     ];
  27.     public const GIFT_FOR_VALUES = [
  28.         // 'him',
  29.         // 'her'
  30.         '7cce7202-a23b-11ed-ab1e-bae0dddde718',
  31.         '7cce7cb6-a23b-11ed-9292-bae0dddde718'
  32.     ];
  34.     public const MAIN_MATERIAL_VALUES = [
  35.         'linen',
  36.         'cotton',
  37.         'gauze',
  38.         'velvet',
  39.         'coated_cotton',
  40.         'cotton_voile',
  41.         'jersey',
  42.         'pleather',
  43.         'suede_fabric',
  44.         'hand_painted'
  45.     ];
  47.     // Selectionne les produits de base (en dur)
  48.     // Grande besace : BASE.BES.CAR.G
  49.     // Petite besace : BASE.BES.P
  50.     // Sac compagnon : BASE.SAC.COM
  51.     // --
  52.     // Rabat grande besace : RABA.BES.CAR.G
  53.     // Rabat petite besace : RABA.BES.P
  54.     // Rabat besace petit nuage : RABA.BES.PET.
  55.     // Rabat sac compagnon : RABA.SAC.COM
  56.     // --
  57.     // Petite Lanière : LANI.P
  58.     // Grande lanière : LANI.G
  59.     public const SACZIP_FORMES = [
  60.         'base' => [
  61.             'grand_besace' => 'BASE.BES.CAR.G',
  62.             'petite_besace' => 'BASE.BES.P',
  63.             'sac_compagnon' => 'BASE.SAC.COM'
  64.         ],
  65.         'rabat' => [
  66.             'rabat_grande_besace' => 'RABA.BES.CAR.G',
  67.             'rabat_petite_besace' => 'RABA.BES.P',
  68.             'rabat_besace_petite_nuage' => 'RABA.BES.PET.',
  69.             'rabat_sac_compagnon' => 'RABA.SAC.COM'
  70.         ],
  71.         'laniere' => [
  72.             'petite_laniere' => 'LANI.P',
  73.             'grande_laniere' => 'LANI.G'
  74.         ]
  75.     ];
  77.     protected $id;
  79.     protected $incomingStock;
  80.     protected $dateIncomingStock;
  82.     protected $attributes;
  84.     protected $coatingType;
  85.     protected $coatingVegetal;
  86.     protected $mainMaterial;
  87.     protected $giftFor;
  89.     protected $badge;
  90.     protected $tags;
  91.     protected $pricePerTwo;
  93.     protected $oldUrl;
  94.     protected $itemMin=5;
  95.     protected $isBlocked;
  96.     protected $taxons;
  98.     public function __construct()
  99.     {
  100.         parent::__construct();
  102.         
  103.         $this->attributes = new ArrayCollection();
  104.     }
  106.     public function setId(int $id): void
  107.     {
  108.         $this->id = $id;
  109.     }
  111.     public function getIncomingStock(): ?int
  112.     {
  113.         return $this->incomingStock;
  114.     }
  116.     public function setIncomingStock(?int $incomingStock): void
  117.     {
  118.         $this->incomingStock = $incomingStock;
  119.     }
  121.     public function getDateIncomingStock()
  122.     {
  123.         return $this->dateIncomingStock;
  124.     }
  126.     public function setDateIncomingStock($dateIncomingStock): void
  127.     {
  128.         $this->dateIncomingStock = $dateIncomingStock;
  129.     }
  131.     public function getCoatingType(): ?string
  132.     {
  133.         return $this->coatingType;
  134.     }
  136.     public function setCoatingType(?string $coatingType): void
  137.     {
  138.         $this->coatingType = $coatingType;
  139.     }
  141.     public function getCoatingVegetal(): ?bool
  142.     {
  143.         return $this->coatingVegetal;
  144.     }
  146.     public function setCoatingVegetal(?bool $coatingVegetal): void
  147.     {
  148.         $this->coatingVegetal = $coatingVegetal;
  149.     }
  151.     public function getMainMaterial(): ?string
  152.     {
  153.         return $this->mainMaterial;
  154.     }
  156.     public function setMainMaterial(?string $mainMaterial): void
  157.     {
  158.         $this->mainMaterial = $mainMaterial;
  159.     }
  161.     public function getGiftFor(): ?string
  162.     {
  163.         return $this->giftFor;
  164.     }
  166.     public function setGiftFor(?string $giftFor): void
  167.     {
  168.         $this->giftFor = $giftFor;
  169.     }
  171.     public function getBadge(): ?string
  172.     {
  173.         return $this->badge;
  174.     }
  176.     public function setBadge(?string $badge): void
  177.     {
  178.         $this->badge = $badge;
  179.     }
  181.     public function getPricePerTwo(): ?string
  182.     {
  183.         return $this->pricePerTwo;
  184.     }
  186.     public function setPricePerTwo(?string $pricePerTwo): void
  187.     {
  188.         $this->pricePerTwo = $pricePerTwo;
  189.     }
  191.     public function getOldUrl(): ?string
  192.     {
  193.         return $this->oldUrl;
  194.     }
  196.     public function setOldUrl(?string $oldUrl): void
  197.     {
  198.         $this->oldUrl = $oldUrl;
  199.     }
  201.     public function getIsBlocked(): ?bool
  202.     {
  203.         return $this->isBlocked;
  204.     }
  206.     public function setIsBlocked(?bool $isBlocked): void
  207.     {
  208.         $this->isBlocked = $isBlocked;
  209.     }
  211.     public function getSlug(): ?string
  212.     {
  213.         return $this->getTranslation()->getSlug();
  214.     }
  216.     public function setSlug(?string $slug): void
  217.     {
  218.         $this->getTranslation()->setSlug($slug);
  219.     }
  221.     public function getDescription(): ?string
  222.     {
  223.         return $this->getTranslation()->getDescription();
  224.     }
  226.     public function setDescription(?string $description): void
  227.     {
  228.         $this->getTranslation()->setDescription($description);
  229.     }
  231.     public function getAdvantages(): ?string
  232.     {
  233.         return $this->getTranslation()->getAdvantages();
  234.     }
  236.     public function setAdvantages(?string $advantages): void
  237.     {
  238.         $this->getTranslation()->setAdvantages($advantages);
  239.     }
  241.     public function getMaintenance(): ?string
  242.     {
  243.         return $this->getTranslation()->getMaintenance();
  244.     }
  246.     public function setMaintenance(?string $maintenance): void
  247.     {
  248.         $this->getTranslation()->setMaintenance($maintenance);
  249.     }
  250.     
  253.     public function getAttributes(): Collection
  254.     {
  255.         
  256.         // dump('coucou');
  257.         // dump($this->attributes);
  258.         // exit();
  259.         return $this->attributes;
  260.     }
  262.     public function getAttributesByLocale(
  263.         string $localeCode,
  264.         string $fallbackLocaleCode,
  265.         ?string $baseLocaleCode = null
  266.     ): Collection {
  267.        
  268.         if (null === $baseLocaleCode || $baseLocaleCode === $fallbackLocaleCode) {
  269.             $baseLocaleCode = $fallbackLocaleCode;
  270.             $fallbackLocaleCode = null;
  271.         }
  273.         $attributes = $this->attributes->filter(
  274.             function (ProductVariantAttributeValueInterface $attribute) use ($baseLocaleCode) {
  275.                 return $attribute->getLocaleCode() === $baseLocaleCode || null === $attribute->getLocaleCode();
  276.             }
  277.         );
  279.         $attributesWithFallback = [];
  280.         foreach ($attributes as $attribute) {
  281.             $attributesWithFallback[] = $this->getAttributeInDifferentLocale($attribute, $localeCode, $fallbackLocaleCode);
  282.         }
  284.         return new ArrayCollection($attributesWithFallback);
  285.     }
  287.     protected function getAttributeInDifferentLocale(
  288.         ProductVariantAttributeValueInterface $attributeValue,
  289.         string $localeCode,
  290.         ?string $fallbackLocaleCode = null
  291.     ) {
  292.         if (!$this->hasNotEmptyAttributeByCodeAndLocale($attributeValue->getCode(), $localeCode)) {
  293.             if (
  294.                 null !== $fallbackLocaleCode &&
  295.                 $this->hasNotEmptyAttributeByCodeAndLocale($attributeValue->getCode(), $fallbackLocaleCode)
  296.             ) {
  297.                 return $this->getAttributeByCodeAndLocale($attributeValue->getCode(), $fallbackLocaleCode);
  298.             }
  300.             return $attributeValue;
  301.         }
  303.         return $this->getAttributeByCodeAndLocale($attributeValue->getCode(), $localeCode);
  304.     }
  306.     protected function hasNotEmptyAttributeByCodeAndLocale(string $attributeCode, string $localeCode): bool
  307.     {
  308.         $attributeValue = $this->getAttributeByCodeAndLocale($attributeCode, $localeCode);
  309.         if (null === $attributeValue) {
  310.             return false;
  311.         }
  313.         $value = $attributeValue->getValue();
  314.         if ('' === $value || null === $value || [] === $value) {
  315.             return false;
  316.         }
  318.         return true;
  319.     }
  321.     public function addAttribute(?ProductVariantAttributeValueInterface  $attribute): void
  322.     {
  323.         /** @var ProductVariantAttributeValueInterface $attribute */
  324.         Assert::isInstanceOf(
  325.             $attribute,
  326.             ProductVariantAttributeValueInterface::class,
  327.             'Attribute objects added to a Product object have to implement ProductVariantAttributeValueInterface'
  328.         );
  330.         if (!$this->hasAttribute($attribute)) {
  331.             $attribute->setProductVariant($this);
  332.             // dump( $attribute);
  333.             // exit();
  334.             $this->attributes->add($attribute);
  335.         }
  336.     }
  338.     public function removeAttribute(?ProductVariantAttributeValueInterface $attribute): void
  339.     {
  340.         /** @var ProductVariantAttributeValueInterface $attribute */
  341.         Assert::isInstanceOf(
  342.             $attribute,
  343.             ProductVariantAttributeValueInterface::class,
  344.             'Attribute objects removed from a Product object have to implement ProductVariantAttributeValueInterface'
  345.         );
  347.         if ($this->hasAttribute($attribute)) {
  348.             $this->attributes->removeElement($attribute);
  349.             $attribute->setProductVariant(null);
  350.         }
  351.     }
  353.     public function hasAttribute(ProductVariantAttributeValueInterface $attribute): bool
  354.     {
  355.         return $this->attributes->contains($attribute);
  356.     }
  358.     public function hasAttributeByCodeAndLocale(string $attributeCode, ?string $localeCode = null): bool
  359.     {
  360.         $localeCode = $localeCode ?: $this->getTranslation()->getLocale();
  362.         foreach ($this->attributes as $attribute) {
  363.             if ($attribute->getAttribute()->getCode() === $attributeCode
  364.                 && ($attribute->getLocaleCode() === $localeCode || null === $attribute->getLocaleCode())) {
  365.                 return true;
  366.             }
  367.         }
  369.         return false;
  370.     }
  372.     public function getAttributeByCodeAndLocale(string $attributeCode, ?string $localeCode = null): ?ProductVariantAttributeValueInterface
  373.     {
  374.         if (null === $localeCode) {
  375.             $localeCode = $this->getTranslation()->getLocale();
  376.         }
  378.         foreach ($this->attributes as $attribute) {
  379.             if ($attribute->getAttribute()->getCode() === $attributeCode &&
  380.                 ($attribute->getLocaleCode() === $localeCode || null === $attribute->getLocaleCode())) {
  381.                 return $attribute;
  382.             }
  383.         }
  385.         return null;
  386.     }
  388.     public function setItemMin(int $itemMin)
  389.     {
  390.         $this->itemMin = $itemMin;
  391.     }
  393.     public function getItemMin(): int
  394.     {
  395.         return $this->itemMin;
  396.     }
  399.     public function canAddItem(): bool
  400.     {
  401.         // echo 'canAddItem - '.OrderItem::itemMin.' -- '.$this->itemMin;
  402.         // if( ($this->getOnHand() - $this->getOnHold() - OrderItem::itemMin /*- $this->getQuantity()*/ ) > 0 && $this->hasImages()){
  403.         //     return true;
  404.         // }
  406.         if($this->getIsBlocked()) {
  407.             return false;
  408.         }
  409.         if($this->getId() == 41360) {
  410.             dump($this);
  411.         }
  412.         
  413.         if( ($this->getOnHand() - $this->getOnHold() - $this->itemMin /*- $this->getQuantity()*/ ) > 0 && $this->hasImages()){
  414.             return true;
  415.         }
  416.     
  417.         return false;
  419.     }
  421.     public function countItemStock(): int
  422.     {
  423.         
  424.           
  425.         // return $this->getOnHand() - $this->getOnHold() - OrderItem::itemMin ;
  426.         return $this->getOnHand() - $this->getOnHold() - $this->itemMin ;
  427.     }
  429.     public function countItemStockTissu(): int
  430.     {
  431.         
  432.           
  433.         // return $this->getOnHand() - $this->getOnHold() - OrderItem::itemMin ;
  435.         return $this->getOnHand() - $this->getOnHold() - $this->itemMin ;
  436.     }
  438.     public function getTaxons()
  439.     {
  440.         $taxons = [];
  441.         foreach($this->taxons as $productVariantTaxon) {
  442.             $taxons[] = $productVariantTaxon->getTaxon();
  443.         }
  445.         return $taxons;
  446.     }
  448.     public function setTaxons($taxons): void
  449.     {
  450.         $this->taxons = $taxons;
  451.     }
  453.     public function getTags()
  454.     {
  455.         if(empty($this->tags)) {
  456.             return [];
  457.         }
  458.         return explode(',', $this->tags);
  459.     }
  461.     public function setTags($tags): void
  462.     {
  463.         $this->tags = implode(',', $tags);
  464.     }
  466. }