classes/XLite/Model/Product.php line 70

Open in your IDE?
  1. <?php
  3. /**
  4.  * Copyright (c) 2011-present Qualiteam software Ltd. All rights reserved.
  5.  * See https://www.x-cart.com/license-agreement.html for license details.
  6.  */
  8. namespace XLite\Model;
  10. use ApiPlatform\Core\Annotation as ApiPlatform;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use XCart\Framework\ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\IntegerDateFilter;
  13. use XLite\API\Endpoint\Product\DTO\ProductInput as ProductInput;
  14. use XLite\API\Endpoint\Product\DTO\ProductOutput as ProductOutput;
  15. use XLite\API\Filter\TranslationAwareOrderFilter;
  16. use XLite\Core\Cache\ExecuteCachedTrait;
  17. use XLite\Core\Converter;
  18. use XLite\Core\Exception\FatalException;
  19. use XLite\Core\Model\EntityVersion\EntityVersionInterface;
  20. use XLite\Core\Model\EntityVersion\EntityVersionTrait;
  21. use XLite\Model\Base\IMark;
  22. use XLite\Model\Product\ProductStockAvailabilityPolicy;
  24. /**
  25.  * The "product" model class
  26.  *
  27.  * @ORM\Entity
  28.  * @ORM\Table  (name="products",
  29.  *      indexes={
  30.  *          @ORM\Index (name="sku", columns={"sku"}),
  31.  *          @ORM\Index (name="price", columns={"price"}),
  32.  *          @ORM\Index (name="weight", columns={"weight"}),
  33.  *          @ORM\Index (name="free_shipping", columns={"free_shipping"}),
  34.  *          @ORM\Index (name="customerArea", columns={"enabled","arrivalDate"}),
  35.  *          @ORM\Index (name="getSearchParamsTypeBetween", columns={"arrivalDate"}),
  36.  *          @ORM\Index (name="prepareCndQtyRange", columns={"amount"}),
  37.  *          @ORM\Index (name="bestsellers", columns={"sales"}),
  38.  *          @ORM\Index (name="isDemo", columns={"isDemoProduct"})
  39.  *      }
  40.  * )
  41.  * @ApiPlatform\ApiResource(
  42.  *     input=ProductInput::class,
  43.  *     output=ProductOutput::class,
  44.  *     itemOperations={
  45.  *         "get"={
  46.  *             "method"="GET",
  47.  *             "path"="/products/{product_id}",
  48.  *             "identifiers"={"product_id"},
  49.  *         },
  50.  *         "put"={
  51.  *             "method"="PUT",
  52.  *             "path"="/products/{product_id}",
  53.  *             "identifiers"={"product_id"},
  54.  *         },
  55.  *         "delete"={
  56.  *             "method"="DELETE",
  57.  *             "path"="/products/{product_id}",
  58.  *             "identifiers"={"product_id"},
  59.  *         }
  60.  *     },
  61.  *     collectionOperations={
  62.  *         "get"={
  63.  *             "method"="GET",
  64.  *             "path"="/products",
  65.  *             "identifiers"={"product_id"},
  66.  *         },
  67.  *         "post"={
  68.  *             "method"="POST",
  69.  *             "path"="/products",
  70.  *             "identifiers"={"product_id"},
  71.  *         }
  72.  *     }
  73.  * )
  74.  * @ApiPlatform\ApiFilter(IntegerDateFilter::class, properties={"updateDate"})
  75.  * @ApiPlatform\ApiFilter(TranslationAwareOrderFilter::class, properties={"name"="ASC","price"="ASC","arrivalDate"="ASC"})
  76.  */
  77. class Product extends \XLite\Model\Base\Catalog implements \XLite\Model\Base\IOrderItem, EntityVersionInterface
  78. {
  79.     use EntityVersionTrait;
  80.     use ExecuteCachedTrait;
  82.     /**
  83.      * Default amounts
  84.      */
  85.     public const AMOUNT_DEFAULT_INV_TRACK = 1000;
  86.     public const AMOUNT_DEFAULT_LOW_LIMIT = 10;
  88.     /**
  89.      * Meta description type
  90.      */
  91.     public const META_DESC_TYPE_AUTO   = 'A';
  92.     public const META_DESC_TYPE_CUSTOM = 'C';
  94.     /**
  95.      * Product unique ID
  96.      *
  97.      * @var integer
  98.      *
  99.      * @ORM\Id
  100.      * @ORM\GeneratedValue (strategy="AUTO")
  101.      * @ORM\Column         (type="integer", options={ "unsigned": true })
  102.      */
  103.     protected $product_id;
  105.     /**
  106.      * Product price
  107.      *
  108.      * @var float
  109.      *
  110.      * @ORM\Column (type="decimal", precision=14, scale=4)
  111.      */
  112.     protected $price = 0.0000;
  114.     /**
  115.      * Product SKU
  116.      *
  117.      * @var string
  118.      *
  119.      * @ORM\Column (type="string", length=32, nullable=true)
  120.      */
  121.     protected $sku;
  123.     /**
  124.      * Is product available or not
  125.      *
  126.      * @var boolean
  127.      *
  128.      * @ORM\Column (type="boolean")
  129.      */
  130.     protected $enabled = true;
  132.     /**
  133.      * Product weight
  134.      *
  135.      * @var float
  136.      *
  137.      * @ORM\Column (type="decimal", precision=14, scale=4)
  138.      */
  139.     protected $weight = 0.0000;
  141.     /**
  142.      * Is product shipped in separate box
  143.      *
  144.      * @var boolean
  145.      *
  146.      * @ORM\Column (type="boolean")
  147.      */
  148.     protected $useSeparateBox = false;
  150.     /**
  151.      * Product box width
  152.      *
  153.      * @var float
  154.      *
  155.      * @ORM\Column (type="decimal", precision=14, scale=4)
  156.      */
  157.     protected $boxWidth = 0.0000;
  159.     /**
  160.      * Product box length
  161.      *
  162.      * @var float
  163.      *
  164.      * @ORM\Column (type="decimal", precision=14, scale=4)
  165.      */
  166.     protected $boxLength = 0.0000;
  168.     /**
  169.      * Product box height
  170.      *
  171.      * @var float
  172.      *
  173.      * @ORM\Column (type="decimal", precision=14, scale=4)
  174.      */
  175.     protected $boxHeight = 0.0000;
  177.     /**
  178.      * How many product items can be placed in a box
  179.      *
  180.      * @var integer
  181.      *
  182.      * @ORM\Column (type="integer")
  183.      */
  184.     protected $itemsPerBox = 1;
  186.     /**
  187.      * Flag: false - product is shippable, true - product is not shippable
  188.      *
  189.      * @var boolean
  190.      *
  191.      * @ORM\Column (type="boolean")
  192.      */
  193.     protected $free_shipping = false;
  195.     /**
  196.      * If false then the product is free from any taxes
  197.      *
  198.      * @var boolean
  199.      *
  200.      * @ORM\Column (type="boolean")
  201.      */
  202.     protected $taxable = true;
  204.     /**
  205.      * Arrival date (UNIX timestamp)
  206.      *
  207.      * @var integer
  208.      *
  209.      * @ORM\Column (type="integer")
  210.      */
  211.     protected $arrivalDate = 0;
  213.     /**
  214.      * Creation date (UNIX timestamp)
  215.      *
  216.      * @var integer
  217.      *
  218.      * @ORM\Column (type="integer")
  219.      */
  220.     protected $date = 0;
  222.     /**
  223.      * Update date (UNIX timestamp)
  224.      *
  225.      * @var integer
  226.      *
  227.      * @ORM\Column (type="integer", options={ "unsigned": true })
  228.      */
  229.     protected $updateDate = 0;
  231.     /**
  232.      * Is product need process or not
  233.      *
  234.      * @var boolean
  235.      *
  236.      * @ORM\Column (type="boolean")
  237.      */
  238.     protected $needProcess = true;
  240.     /**
  241.      * Relation to a CategoryProducts entities
  242.      *
  243.      * @var \Doctrine\ORM\PersistentCollection
  244.      *
  245.      * @ORM\OneToMany (targetEntity="XLite\Model\CategoryProducts", mappedBy="product", cascade={"all"})
  246.      * @ORM\OrderBy   ({"orderbyInProduct" = "ASC"})
  247.      */
  248.     protected $categoryProducts;
  250.     /**
  251.      * Product order items
  252.      *
  253.      * @var \XLite\Model\OrderItem
  254.      *
  255.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderItem", mappedBy="object")
  256.      */
  257.     protected $order_items;
  259.     /**
  260.      * Product images
  261.      *
  262.      * @var \Doctrine\Common\Collections\Collection
  263.      *
  264.      * @ORM\OneToMany (targetEntity="XLite\Model\Image\Product\Image", mappedBy="product", cascade={"all"})
  265.      * @ORM\OrderBy   ({"orderby" = "ASC"})
  266.      */
  267.     protected $images;
  269.     // {{{ Inventory properties
  271.     /**
  272.      * Is inventory tracking enabled or not
  273.      *
  274.      * @var boolean
  275.      *
  276.      * @ORM\Column (type="boolean")
  277.      */
  278.     protected $inventoryEnabled = true;
  280.     /**
  281.      * Amount
  282.      *
  283.      * @var integer
  284.      *
  285.      * @ORM\Column (type="integer", options={ "unsigned": true })
  286.      */
  287.     protected $amount = self::AMOUNT_DEFAULT_INV_TRACK;
  289.     /**
  290.      * Is low limit notification enabled for customer or not
  291.      *
  292.      * @var boolean
  293.      *
  294.      * @ORM\Column (type="boolean")
  295.      */
  296.     protected $lowLimitEnabledCustomer = true;
  298.     /**
  299.      * Is low limit notification enabled for admin or not
  300.      *
  301.      * @var boolean
  302.      *
  303.      * @ORM\Column (type="boolean")
  304.      */
  305.     protected $lowLimitEnabled = false;
  307.     /**
  308.      * Low limit amount
  309.      *
  310.      * @var integer
  311.      *
  312.      * @ORM\Column (type="integer", options={ "unsigned": true })
  313.      */
  314.     protected $lowLimitAmount = self::AMOUNT_DEFAULT_LOW_LIMIT;
  316.     // }}}
  318.     /**
  319.      * Product class (relation)
  320.      *
  321.      * @var \XLite\Model\ProductClass
  322.      *
  323.      * @ORM\ManyToOne  (targetEntity="XLite\Model\ProductClass")
  324.      * @ORM\JoinColumn (name="product_class_id", referencedColumnName="id", onDelete="SET NULL")
  325.      */
  326.     protected $productClass;
  328.     /**
  329.      * Tax class (relation)
  330.      *
  331.      * @var \XLite\Model\TaxClass
  332.      *
  333.      * @ORM\ManyToOne  (targetEntity="XLite\Model\TaxClass")
  334.      * @ORM\JoinColumn (name="tax_class_id", referencedColumnName="id", onDelete="SET NULL")
  335.      */
  336.     protected $taxClass;
  338.     /**
  339.      * Attributes
  340.      *
  341.      * @var \Doctrine\Common\Collections\Collection
  342.      *
  343.      * @ORM\OneToMany (targetEntity="XLite\Model\Attribute", mappedBy="product", cascade={"all"})
  344.      * @ORM\OrderBy   ({"position" = "ASC"})
  345.      */
  346.     protected $attributes;
  348.     /**
  349.      * Attribute value (checkbox)
  350.      *
  351.      * @var \Doctrine\Common\Collections\Collection
  352.      *
  353.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueCheckbox", mappedBy="product", cascade={"all"})
  354.      */
  355.     protected $attributeValueC;
  357.     /**
  358.      * Attribute value (text)
  359.      *
  360.      * @var \Doctrine\Common\Collections\Collection
  361.      *
  362.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueText", mappedBy="product", cascade={"all"})
  363.      */
  364.     protected $attributeValueT;
  366.     /**
  367.      * Attribute value (select)
  368.      *
  369.      * @var \Doctrine\Common\Collections\Collection
  370.      *
  371.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueSelect", mappedBy="product", cascade={"all"})
  372.      */
  373.     protected $attributeValueS;
  375.     /**
  376.      * Attribute value (hidden)
  377.      *
  378.      * @var \Doctrine\Common\Collections\Collection
  379.      *
  380.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueHidden", mappedBy="product", cascade={"all"})
  381.      */
  382.     protected $attributeValueH;
  384.     /**
  385.      * Show product attributes in a separate tab
  386.      *
  387.      * @var boolean
  388.      *
  389.      * @ORM\Column (type="boolean")
  390.      */
  391.     protected $attrSepTab = true;
  393.     /**
  394.      * How much product is sold (used in Top selling products statistics)
  395.      *
  396.      * @var integer
  397.      */
  398.     protected $sold = 0;
  400.     /**
  401.      * Quick data
  402.      *
  403.      * @var \Doctrine\Common\Collections\Collection
  404.      *
  405.      * @ORM\OneToMany (targetEntity="XLite\Model\QuickData", mappedBy="product", cascade={"all"})
  406.      */
  407.     protected $quickData;
  409.     /**
  410.      * Storage of current attribute values according to the clear price will be calculated
  411.      *
  412.      * @var array
  413.      */
  414.     protected $attrValues = [];
  416.     /**
  417.      * Memberships
  418.      *
  419.      * @var \Doctrine\Common\Collections\ArrayCollection
  420.      *
  421.      * @ORM\ManyToMany (targetEntity="XLite\Model\Membership", inversedBy="products")
  422.      * @ORM\JoinTable (name="product_membership_links",
  423.      *      joinColumns={@ORM\JoinColumn (name="product_id", referencedColumnName="product_id", onDelete="CASCADE")},
  424.      *      inverseJoinColumns={@ORM\JoinColumn (name="membership_id", referencedColumnName="membership_id", onDelete="CASCADE")}
  425.      * )
  426.      */
  427.     protected $memberships;
  429.     /**
  430.      * Clean URLs
  431.      *
  432.      * @var \Doctrine\Common\Collections\Collection
  433.      *
  434.      * @ORM\OneToMany (targetEntity="XLite\Model\CleanURL", mappedBy="product", cascade={"all"})
  435.      * @ORM\OrderBy   ({"id" = "ASC"})
  436.      */
  437.     protected $cleanURLs;
  439.     /**
  440.      * Meta description type
  441.      *
  442.      * @var string
  443.      *
  444.      * @ORM\Column (type="string", length=1)
  445.      */
  446.     protected $metaDescType = 'A';
  448.     /**
  449.      * Sales
  450.      *
  451.      * @var integer
  452.      *
  453.      * @ORM\Column (type="integer", options={ "unsigned": true })
  454.      */
  455.     protected $sales = 0;
  457.     /**
  458.      * Flag to exporting entities
  459.      *
  460.      * @var boolean
  461.      *
  462.      * @ORM\Column (type="boolean")
  463.      */
  464.     protected $xcPendingExport = false;
  466.     /**
  467.      * @var \Doctrine\Common\Collections\Collection
  468.      *
  469.      * @ORM\OneToMany (targetEntity="XLite\Model\ProductTranslation", mappedBy="owner", cascade={"all"})
  470.      */
  471.     protected $translations;
  473.     /**
  474.      * Flag for demo products.
  475.      *
  476.      * @ORM\Column (type="boolean")
  477.      */
  478.     protected bool $isDemoProduct = false;
  480.     /**
  481.      * Return GlobalTabs
  482.      *
  483.      * @return \XLite\Model\Product\GlobalTab[]
  484.      */
  485.     public function getGlobalTabs()
  486.     {
  487.         return $this->executeCachedRuntime(static function () {
  488.             return \XLite\Core\Database::getRepo('\XLite\Model\Product\GlobalTab')->findAll();
  489.         }, ['getGlobalTabs']);
  490.     }
  492.     /**
  493.      * Clone
  494.      *
  495.      * @return static
  496.      */
  497.     public function cloneEntity()
  498.     {
  499.         /** @var Product $newProduct */
  500.         $newProduct = parent::cloneEntity();
  502.         $this->cloneEntityScalar($newProduct);
  504.         if (!$newProduct->update() || !$newProduct->getProductId()) {
  505.             throw new FatalException('Can not clone product');
  506.         }
  508.         $this->cloneEntityModels($newProduct);
  509.         $this->cloneEntityCategories($newProduct);
  510.         $this->cloneEntityAttributes($newProduct);
  511.         $this->cloneEntityImages($newProduct);
  512.         $this->cloneEntityMemberships($newProduct);
  514.         $newProduct->update();
  516.         foreach ($newProduct->getCleanURLs() as $url) {
  517.             $newProduct->getCleanURLs()->removeElement($url);
  518.             \XLite\Core\Database::getEM()->remove($url);
  519.         }
  521.         $newProduct->setSales(0);
  523.         return $newProduct;
  524.     }
  526.     /**
  527.      * Clone entity (scalar fields)
  528.      *
  529.      * @param Product $newProduct New product
  530.      *
  531.      * @return void
  532.      */
  533.     protected function cloneEntityScalar(Product $newProduct)
  534.     {
  535.         $newProduct->setSku(\XLite\Core\Database::getRepo('XLite\Model\Product')->assembleUniqueSKU($this->getSku()));
  536.         $newProduct->setName($this->getCloneName($this->getName()));
  537.     }
  539.     /**
  540.      * Clone entity (model fields)
  541.      *
  542.      * @param Product $newProduct New product
  543.      *
  544.      * @return void
  545.      */
  546.     protected function cloneEntityModels(Product $newProduct)
  547.     {
  548.         $newProduct->setTaxClass($this->getTaxClass());
  549.         $newProduct->setProductClass($this->getProductClass());
  550.     }
  552.     /**
  553.      * Clone entity (categories)
  554.      *
  555.      * @param Product $newProduct New product
  556.      *
  557.      * @return void
  558.      */
  559.     protected function cloneEntityCategories(Product $newProduct)
  560.     {
  561.         foreach ($this->getCategories() as $category) {
  562.             $link = new \XLite\Model\CategoryProducts();
  563.             $link->setProduct($newProduct);
  564.             $link->setCategory($category);
  565.             $newProduct->addCategoryProducts($link);
  566.             \XLite\Core\Database::getEM()->persist($link);
  567.         }
  568.     }
  570.     /**
  571.      * Clone entity (attributes)
  572.      *
  573.      * @param Product $newProduct New product
  574.      *
  575.      * @return void
  576.      */
  577.     protected function cloneEntityAttributes(Product $newProduct)
  578.     {
  579.         foreach (\XLite\Model\Attribute::getTypes() as $type => $name) {
  580.             $methodGet = 'getAttributeValue' . $type;
  581.             $methodAdd = 'addAttributeValue' . $type;
  582.             $groups    = [];
  583.             foreach ($this->$methodGet() as $value) {
  584.                 if (!$value->getAttribute()->getProduct()) {
  585.                     $newValue = $value->cloneEntity();
  586.                     $newValue->setProduct($newProduct);
  587.                     $newProduct->$methodAdd($newValue);
  588.                     \XLite\Core\Database::getEM()->persist($newValue);
  590.                     $attribute = $value->getAttribute();
  591.                     $property  = $attribute->getProperty($value->getProduct());
  592.                     if ($property && $value instanceof \XLite\Model\AttributeValue\Multiple) {
  593.                         $groups[$attribute->getId()] = [
  594.                             'attr'     => $attribute,
  595.                             'property' => $property,
  596.                         ];
  597.                     }
  598.                 }
  599.             }
  601.             foreach ($groups as $group) {
  602.                 $newProperty = $group['property']->cloneEntity();
  603.                 $newProperty->setProduct($newProduct);
  604.                 $newProperty->setAttribute($group['attr']);
  605.                 \XLite\Core\Database::getEM()->persist($newProperty);
  606.             }
  607.         }
  609.         foreach ($this->getAttributes() as $attribute) {
  610.             $class        = $attribute->getAttributeValueClass($attribute->getType());
  611.             $repo         = \XLite\Core\Database::getRepo($class);
  612.             $methodAdd    = 'addAttributeValue' . $attribute->getType();
  613.             $newAttribute = $attribute->cloneEntity();
  614.             $newAttribute->setProduct($newProduct);
  615.             $newProduct->addAttributes($newAttribute);
  616.             \XLite\Core\Database::getEM()->persist($newAttribute);
  617.             foreach ($repo->findBy(['attribute' => $attribute, 'product' => $this]) as $value) {
  618.                 $newValue = $value->cloneEntity();
  619.                 $newValue->setProduct($newProduct);
  620.                 $newValue->setAttribute($newAttribute);
  621.                 $newProduct->$methodAdd($newValue);
  622.                 \XLite\Core\Database::getEM()->persist($newValue);
  623.             }
  624.         }
  625.     }
  627.     /**
  628.      * Clone entity (images)
  629.      *
  630.      * @param Product $newProduct New product
  631.      *
  632.      * @return void
  633.      */
  634.     protected function cloneEntityImages(Product $newProduct)
  635.     {
  636.         foreach ($this->getImages() as $image) {
  637.             $newImage = $image->cloneEntity();
  638.             $newImage->setProduct($newProduct);
  639.             $newProduct->addImages($newImage);
  640.         }
  641.     }
  643.     /**
  644.      * Clone entity (memberships)
  645.      *
  646.      * @param Product $newProduct New product
  647.      *
  648.      * @return void
  649.      */
  650.     protected function cloneEntityMemberships(Product $newProduct)
  651.     {
  652.         foreach ($this->getMemberships() as $membership) {
  653.             $newProduct->addMemberships($membership);
  654.         }
  655.     }
  657.     /**
  658.      * Constructor
  659.      *
  660.      * @param array $data Entity properties OPTIONAL
  661.      */
  662.     public function __construct(array $data = [])
  663.     {
  664.         $this->categoryProducts = new \Doctrine\Common\Collections\ArrayCollection();
  665.         $this->images           = new \Doctrine\Common\Collections\ArrayCollection();
  666.         $this->order_items      = new \Doctrine\Common\Collections\ArrayCollection();
  667.         $this->memberships      = new \Doctrine\Common\Collections\ArrayCollection();
  668.         $this->attributeValueC  = new \Doctrine\Common\Collections\ArrayCollection();
  669.         $this->attributeValueS  = new \Doctrine\Common\Collections\ArrayCollection();
  670.         $this->attributeValueT  = new \Doctrine\Common\Collections\ArrayCollection();
  671.         $this->attributes       = new \Doctrine\Common\Collections\ArrayCollection();
  672.         $this->quickData        = new \Doctrine\Common\Collections\ArrayCollection();
  673.         $this->free_shipping    = !\XLite\Core\Config::getInstance()->General->requires_shipping_default;
  675.         parent::__construct($data);
  676.     }
  678.     /**
  679.      * Get object unique id
  680.      *
  681.      * @return integer
  682.      */
  683.     public function getId()
  684.     {
  685.         return $this->getProductId();
  686.     }
  688.     /**
  689.      * Get weight
  690.      *
  691.      * @return float
  692.      */
  693.     public function getWeight()
  694.     {
  695.         return $this->weight;
  696.     }
  698.     /**
  699.      * Get price: modules should never overwrite this method
  700.      *
  701.      * @return float
  702.      */
  703.     public function getPrice()
  704.     {
  705.         return $this->price;
  706.     }
  708.     /**
  709.      * Get clear price: this price can be overwritten by modules
  710.      *
  711.      * @return float
  712.      */
  713.     public function getClearPrice()
  714.     {
  715.         return $this->getPrice();
  716.     }
  718.     /**
  719.      * Get net Price
  720.      *
  721.      * @return float
  722.      */
  723.     public function getNetPrice()
  724.     {
  725.         return \XLite\Logic\Price::getInstance()->apply($this, 'getClearPrice', ['taxable'], 'net');
  726.     }
  728.     /**
  729.      * Get display Price
  730.      *
  731.      * @return float
  732.      */
  733.     public function getDisplayPrice()
  734.     {
  735.         return \XLite\Logic\Price::getInstance()->apply($this, 'getNetPrice', ['taxable'], 'display');
  736.     }
  738.     /**
  739.      * Get quick data price
  740.      *
  741.      * @return float
  742.      */
  743.     public function getQuickDataPrice()
  744.     {
  745.         $price = $this->getClearPrice();
  747.         foreach ($this->prepareAttributeValues() as $av) {
  748.             if (is_object($av)) {
  749.                 $price += $av->getAbsoluteValue('price');
  750.             }
  751.         }
  753.         return $price;
  754.     }
  756.     /**
  757.      * Get clear weight
  758.      *
  759.      * @return float
  760.      */
  761.     public function getClearWeight()
  762.     {
  763.         return $this->getWeight();
  764.     }
  766.     /**
  767.      * Get name
  768.      *
  769.      * @return string
  770.      */
  771.     public function getName()
  772.     {
  773.         return $this->getSoftTranslation()->getName();
  774.     }
  776.     /**
  777.      * Get SKU
  778.      *
  779.      * @return string
  780.      */
  781.     public function getSku()
  782.     {
  783.         return $this->sku !== null ? (string) $this->sku : null;
  784.     }
  786.     /**
  787.      * Get quantity of the product
  788.      *
  789.      * @return integer
  790.      */
  791.     public function getQty()
  792.     {
  793.         return $this->getPublicAmount();
  794.     }
  796.     /**
  797.      * Get image
  798.      *
  799.      * @return \XLite\Model\Image\Product\Image
  800.      */
  801.     public function getImage()
  802.     {
  803.         return $this->getImages()->get(0);
  804.     }
  806.     /**
  807.      * Get public images
  808.      *
  809.      * @return array
  810.      */
  811.     public function getPublicImages()
  812.     {
  813.         return $this->getImages()->toArray();
  814.     }
  816.     /**
  817.      * Get free shipping flag
  818.      *
  819.      * @return boolean
  820.      */
  821.     public function getFreeShipping()
  822.     {
  823.         return $this->free_shipping;
  824.     }
  826.     /**
  827.      * Get shippable flag
  828.      *
  829.      * @return boolean
  830.      */
  831.     public function getShippable()
  832.     {
  833.         return !$this->getFreeShipping();
  834.     }
  836.     /**
  837.      * Set shippable flag
  838.      *
  839.      * @param boolean $value Value
  840.      *
  841.      * @return void
  842.      */
  843.     public function setShippable($value)
  844.     {
  845.         $this->setFreeShipping(!$value);
  846.     }
  848.     /**
  849.      * Return true if product can be purchased
  850.      *
  851.      * @return boolean
  852.      */
  853.     public function isAvailable()
  854.     {
  855.         return \XLite::isAdminZone() || $this->isPublicAvailable();
  856.     }
  858.     /**
  859.      * Return true if product can be purchased in customer interface
  860.      *
  861.      * @return boolean
  862.      */
  863.     public function isPublicAvailable()
  864.     {
  865.         return $this->isVisible()
  866.             && $this->availableInDate()
  867.             && !$this->isOutOfStock();
  868.     }
  870.     /**
  871.      * Check product visibility
  872.      *
  873.      * @return boolean
  874.      */
  875.     public function isVisible()
  876.     {
  877.         return $this->getEnabled()
  878.             && $this->hasAvailableMembership();
  879.     }
  881.     /**
  882.      * Get membership Ids
  883.      *
  884.      * @return array
  885.      */
  886.     public function getMembershipIds()
  887.     {
  888.         $result = [];
  890.         foreach ($this->getMemberships() as $membership) {
  891.             $result[] = $membership->getMembershipId();
  892.         }
  894.         return $result;
  895.     }
  897.     /**
  898.      * Flag if the category and active profile have the same memberships. (when category is displayed or hidden)
  899.      *
  900.      * @return boolean
  901.      */
  902.     public function hasAvailableMembership()
  903.     {
  904.         return $this->getMemberships()->count() === 0
  905.             || in_array(\XLite\Core\Auth::getInstance()->getMembershipId(), $this->getMembershipIds());
  906.     }
  908.     /**
  909.      * Flag if the product is available according date/time
  910.      *
  911.      * @return boolean
  912.      */
  913.     public function availableInDate()
  914.     {
  915.         return !$this->getArrivalDate()
  916.             || \XLite\Core\Converter::getDayEnd(static::getUserTime()) > $this->getArrivalDate();
  917.     }
  919.     /**
  920.      * Check if product has image or not
  921.      *
  922.      * @return boolean
  923.      */
  924.     public function hasImage()
  925.     {
  926.         return $this->getImage() !== null && $this->getImage()->isPersistent();
  927.     }
  929.     /**
  930.      * Return image URL
  931.      *
  932.      * @return string|void
  933.      */
  934.     public function getImageURL()
  935.     {
  936.         return $this->getImage() ? $this->getImage()->getURL() : null;
  937.     }
  939.     /**
  940.      * Return random product category
  941.      *
  942.      * @param integer|null $categoryId Category ID OPTIONAL
  943.      *
  944.      * @return \XLite\Model\Category
  945.      */
  946.     public function getCategory($categoryId = null)
  947.     {
  948.         $result = $this->getLink($categoryId)->getCategory();
  950.         if (empty($result)) {
  951.             $result = new \XLite\Model\Category();
  952.         }
  954.         return $result;
  955.     }
  957.     /**
  958.      * Return random product category ID
  959.      *
  960.      * @param integer|null $categoryId Category ID OPTIONAL
  961.      *
  962.      * @return integer
  963.      */
  964.     public function getCategoryId($categoryId = null)
  965.     {
  966.         return $this->getCategory($categoryId)->getCategoryId();
  967.     }
  969.     /**
  970.      * Return list of product categories
  971.      *
  972.      * @return array
  973.      */
  974.     public function getCategories()
  975.     {
  976.         $result = [];
  978.         foreach ($this->getCategoryProducts() as $cp) {
  979.             $result[] = $cp->getCategory();
  980.         }
  982.         return $result;
  983.     }
  985.     // {{{ Inventory methods
  987.     /**
  988.      * Setter
  989.      *
  990.      * @param int $value Value to set
  991.      *
  992.      * @return void
  993.      */
  994.     public function setAmount($value)
  995.     {
  996.         $this->amount = $this->correctAmount($value);
  997.     }
  999.     /**
  1000.      * Setter
  1001.      *
  1002.      * @param integer $amount Amount to set
  1003.      *
  1004.      * @return void
  1005.      */
  1006.     public function setLowLimitAmount($amount)
  1007.     {
  1008.         $this->lowLimitAmount = $this->correctAmount($amount);
  1009.     }
  1011.     /**
  1012.      * Increase / decrease product inventory amount
  1013.      *
  1014.      * @param integer $delta Amount delta
  1015.      *
  1016.      * @return void
  1017.      */
  1018.     public function changeAmount($delta)
  1019.     {
  1020.         if ($this->getInventoryEnabled()) {
  1021.             $this->setAmount($this->getPublicAmount() + $delta);
  1022.         }
  1023.     }
  1025.     /**
  1026.      * Get public amount
  1027.      *
  1028.      * @return integer
  1029.      */
  1030.     public function getPublicAmount()
  1031.     {
  1032.         return $this->getAmount();
  1033.     }
  1035.     /**
  1036.      * Get low available amount
  1037.      *
  1038.      * @return integer
  1039.      */
  1040.     public function getLowAvailableAmount()
  1041.     {
  1042.         return $this->getInventoryEnabled()
  1043.             ? min($this->getLowDefaultAmount(), $this->getAvailableAmount())
  1044.             : $this->getLowDefaultAmount();
  1045.     }
  1047.     /**
  1048.      * Check if product amount is less than its low limit
  1049.      *
  1050.      * @return boolean
  1051.      */
  1052.     public function isLowLimitReached()
  1053.     {
  1054.         return $this->getInventoryEnabled()
  1055.             && $this->getLowLimitEnabled()
  1056.             && $this->getPublicAmount() <= $this->getLowLimitAmount();
  1057.     }
  1059.     /**
  1060.      * List of controllers which should not send notifications
  1061.      *
  1062.      * @return array
  1063.      */
  1064.     protected function getForbiddenControllers()
  1065.     {
  1066.         return [
  1067.             '\XLite\Controller\Admin\EventTask',
  1068.             '\XLite\Controller\Admin\ProductList',
  1069.             '\XLite\Controller\Admin\Product',
  1070.         ];
  1071.     }
  1073.     /**
  1074.      * Check if notifications should be sended in current situation
  1075.      *
  1076.      * @return boolean
  1077.      */
  1078.     public function isShouldSend()
  1079.     {
  1080.         $result = false;
  1082.         if (!defined('LC_CACHE_BUILDING')) {
  1083.             $currentController     = \XLite::getInstance()->getController();
  1084.             $isControllerForbidden = array_reduce(
  1085.                 $this->getForbiddenControllers(),
  1086.                 static function ($carry, $controllerName) use ($currentController) {
  1087.                     return $carry ?: ($currentController instanceof $controllerName);
  1088.                 },
  1089.                 false
  1090.             );
  1092.             $result = \XLite\Core\Request::getInstance()->event !== 'import'
  1093.                 && !$isControllerForbidden;
  1094.         }
  1096.         return $result;
  1097.     }
  1099.     /**
  1100.      * Check and (if needed) correct amount value
  1101.      *
  1102.      * @param integer $amount Value to check
  1103.      *
  1104.      * @return integer
  1105.      */
  1106.     protected function correctAmount($amount)
  1107.     {
  1108.         return Converter::toUnsigned32BitInt($amount);
  1109.     }
  1111.     /**
  1112.      * Get a low default amount
  1113.      *
  1114.      * @return integer
  1115.      */
  1116.     protected function getLowDefaultAmount()
  1117.     {
  1118.         return 1;
  1119.     }
  1121.     /**
  1122.      * Default qty value to show to customers
  1123.      *
  1124.      * @return integer
  1125.      */
  1126.     public function getDefaultAmount()
  1127.     {
  1128.         return static::AMOUNT_DEFAULT_INV_TRACK;
  1129.     }
  1131.     /**
  1132.      * Get ProductStockAvailabilityPolicy associated with this product
  1133.      *
  1134.      * @return ProductStockAvailabilityPolicy
  1135.      */
  1136.     public function getStockAvailabilityPolicy()
  1137.     {
  1138.         return new ProductStockAvailabilityPolicy($this);
  1139.     }
  1141.     /**
  1142.      * Return product amount available to add to cart
  1143.      *
  1144.      * @return integer
  1145.      */
  1146.     public function getAvailableAmount()
  1147.     {
  1148.         return $this->getStockAvailabilityPolicy()->getAvailableAmount(Cart::getInstance());
  1149.     }
  1151.     /**
  1152.      * Alias: is product in stock or not
  1153.      *
  1154.      * @return boolean
  1155.      */
  1156.     public function isOutOfStock()
  1157.     {
  1158.         return $this->getAmount() <= 0 && $this->getInventoryEnabled();
  1159.     }
  1161.     /**
  1162.      * Alias: is all product items in cart
  1163.      *
  1164.      * @return boolean
  1165.      */
  1166.     public function isAllStockInCart()
  1167.     {
  1168.         return $this->getStockAvailabilityPolicy()->isAllStockInCart(Cart::getInstance());
  1169.     }
  1171.     /**
  1172.      * How many product items added to cart
  1173.      *
  1174.      * @return boolean
  1175.      */
  1176.     public function getItemsInCart()
  1177.     {
  1178.         return $this->getStockAvailabilityPolicy()->getInCartAmount(Cart::getInstance());
  1179.     }
  1181.     /**
  1182.      * How many product items added to cart
  1183.      *
  1184.      * @return boolean
  1185.      */
  1186.     public function getItemsInCartMessage()
  1187.     {
  1188.         $count = $this->getStockAvailabilityPolicy()->getInCartAmount(Cart::getInstance());
  1190.         return \XLite\Core\Translation::getInstance()->translate(
  1191.             'Items in your cart: X',
  1192.             ['count' => $count]
  1193.         );
  1194.     }
  1196.     /**
  1197.      * Check if the product is out-of-stock
  1198.      *
  1199.      * @return boolean
  1200.      */
  1201.     public function isShowStockWarning()
  1202.     {
  1203.         return $this->getInventoryEnabled()
  1204.             && $this->getLowLimitEnabledCustomer()
  1205.             && $this->getPublicAmount() <= $this->getLowLimitAmount()
  1206.             && !$this->isOutOfStock();
  1207.     }
  1209.     /**
  1210.      * Check if the product is out-of-stock
  1211.      *
  1212.      * @return boolean
  1213.      */
  1214.     public function isShowOutOfStockWarning()
  1215.     {
  1216.         return $this->getInventoryEnabled()
  1217.             && $this->isOutOfStock();
  1218.     }
  1220.     /**
  1221.      * Send notification to admin about product low limit
  1222.      *
  1223.      * @return void
  1224.      */
  1225.     public function sendLowLimitNotification()
  1226.     {
  1227.         \XLite\Core\Mailer::sendLowLimitWarningAdmin($this->prepareDataForNotification());
  1228.     }
  1230.     /**
  1231.      * Prepare data for 'low limit warning' email notifications
  1232.      *
  1233.      * @return array
  1234.      */
  1235.     public function prepareDataForNotification()
  1236.     {
  1237.         $data = [];
  1239.         $data['product'] = $this;
  1240.         $data['name']    = $this->getName();
  1241.         $data['sku']     = $this->getSKU();
  1242.         $data['amount']  = $this->getAmount();
  1244.         $params           = [
  1245.             'product_id' => $this->getProductId(),
  1246.             'page'       => 'inventory',
  1247.         ];
  1248.         $data['adminURL'] = \XLite\Core\Converter::buildFullURL('product', '', $params, \XLite::getAdminScript(), false);
  1250.         return $data;
  1251.     }
  1253.     // }}}
  1255.     /**
  1256.      * Set sku and trim it to max length
  1257.      *
  1258.      * @param string $sku
  1259.      *
  1260.      * @return void
  1261.      */
  1262.     public function setSku($sku)
  1263.     {
  1264.         $this->sku = substr(
  1265.             $sku,
  1266.             0,
  1267.             \XLite\Core\Database::getRepo('XLite\Model\Product')->getFieldInfo('sku', 'length')
  1268.         );
  1269.     }
  1271.     /**
  1272.      * Get product Url
  1273.      *
  1274.      * @return string
  1275.      */
  1276.     public function getURL()
  1277.     {
  1278.         return $this->getProductId()
  1279.             ? \XLite\Core\Converter::makeURLValid(
  1280.                 \XLite\Core\Converter::buildURL('product', '', ['product_id' => $this->getProductId()])
  1281.             )
  1282.             : null;
  1283.     }
  1285.     /**
  1286.      * Get front URL
  1287.      *
  1288.      * @return string
  1289.      */
  1290.     public function getFrontURL($withAttributes = false, $buildCuInAdminZone = false)
  1291.     {
  1292.         return $this->getProductId()
  1293.             ? \XLite\Core\Converter::makeURLValid(
  1294.                 \XLite::getInstance()->getShopURL(
  1295.                     \XLite\Core\Converter::buildURL(
  1296.                         'product',
  1297.                         '',
  1298.                         $this->getParamsForFrontURL($withAttributes),
  1299.                         \XLite::getCustomerScript(),
  1300.                         $buildCuInAdminZone
  1301.                     )
  1302.                 )
  1303.             )
  1304.             : null;
  1305.     }
  1307.     /**
  1308.      * @return array
  1309.      */
  1310.     protected function getParamsForFrontURL($withAttributes = false)
  1311.     {
  1312.         $result = [
  1313.             'product_id' => $this->getProductId(),
  1314.         ];
  1316.         if ($withAttributes) {
  1317.             $result['attribute_values'] = $this->getAttributeValuesParams();
  1318.         }
  1320.         return $result;
  1321.     }
  1323.     /**
  1324.      * @return string
  1325.      */
  1326.     protected function getAttributeValuesParams()
  1327.     {
  1328.         $validAttributes = array_filter(
  1329.             $this->getAttrValues(),
  1330.             static function ($attr) {
  1331.                 return $attr && $attr->getAttribute();
  1332.             }
  1333.         );
  1335.         $paramsStrings = array_map(
  1336.             static function ($attr) {
  1337.                 return $attr->getAttribute()->getId() . '_' . $attr->getId();
  1338.             },
  1339.             $validAttributes
  1340.         );
  1342.         return trim(join(',', $paramsStrings), ',');
  1343.     }
  1345.     /**
  1346.      * Minimal available amount
  1347.      *
  1348.      * @return integer
  1349.      */
  1350.     public function getMinPurchaseLimit()
  1351.     {
  1352.         return 1;
  1353.     }
  1355.     /**
  1356.      * Maximal available amount
  1357.      *
  1358.      * @return integer
  1359.      */
  1360.     public function getMaxPurchaseLimit()
  1361.     {
  1362.         return (int) \XLite\Core\Config::getInstance()->General->default_purchase_limit;
  1363.     }
  1365.     /**
  1366.      * Return product position in category
  1367.      *
  1368.      * @param integer|null $categoryId Category ID OPTIONAL
  1369.      *
  1370.      * @return integer|void
  1371.      */
  1372.     public function getOrderBy($categoryId = null)
  1373.     {
  1374.         $link = $this->getLink($categoryId);
  1376.         return $link ? $link->getOrderBy() : null;
  1377.     }
  1379.     /**
  1380.      * Count product images
  1381.      *
  1382.      * @return integer
  1383.      */
  1384.     public function countImages()
  1385.     {
  1386.         return count($this->getPublicImages());
  1387.     }
  1389.     /**
  1390.      * Try to fetch product description
  1391.      *
  1392.      * @return string
  1393.      */
  1394.     public function getCommonDescription()
  1395.     {
  1396.         return $this->getBriefDescription() ?: $this->getDescription();
  1397.     }
  1399.     /**
  1400.      * Get processed product brief description
  1401.      *
  1402.      * @return string
  1403.      */
  1404.     public function getProcessedBriefDescription()
  1405.     {
  1406.         $value = $this->getBriefDescription();
  1408.         return $value
  1409.             ? static::getPreprocessedValue($value)
  1410.             : $value;
  1411.     }
  1413.     /**
  1414.      * Get processed product description
  1415.      *
  1416.      * @return string
  1417.      */
  1418.     public function getProcessedDescription()
  1419.     {
  1420.         $value = $this->getDescription();
  1422.         return $value
  1423.             ? static::getPreprocessedValue($value)
  1424.             : $value;
  1425.     }
  1427.     /**
  1428.      * Get taxable basis
  1429.      *
  1430.      * @return float
  1431.      */
  1432.     public function getTaxableBasis()
  1433.     {
  1434.         return $this->getNetPrice();
  1435.     }
  1438.     /**
  1439.      * Check if product inventory changed
  1440.      *
  1441.      * @return boolean
  1442.      */
  1443.     public function isInventoryChanged()
  1444.     {
  1445.         $changeset = \XLite\Core\Database::getEM()
  1446.             ->getUnitOfWork()
  1447.             ->getEntityChangeSet($this);
  1449.         return isset($changeset['amount']);
  1450.     }
  1452.     /**
  1453.      * Set product class
  1454.      *
  1455.      * @param ProductClass|null $productClass     Product class OPTIONAL
  1456.      * @param boolean           $preprocessChange Flag if use preprocessChangeProductClass() OPTIONAL
  1457.      *
  1458.      * @return Product
  1459.      */
  1460.     public function setProductClass(\XLite\Model\ProductClass $productClass = null, $preprocessChange = true)
  1461.     {
  1462.         if (
  1463.             $preprocessChange
  1464.             && $this->productClass
  1465.             && (
  1466.                 !$productClass
  1467.                 || $productClass->getId() !== $this->productClass->getId()
  1468.             )
  1469.         ) {
  1470.             $this->preprocessChangeProductClass();
  1471.         }
  1473.         $this->productClass = $productClass;
  1475.         return $this;
  1476.     }
  1478.     /**
  1479.      * Get attr values
  1480.      *
  1481.      * @return array
  1482.      */
  1483.     public function getAttrValues()
  1484.     {
  1485.         return $this->attrValues;
  1486.     }
  1488.     /**
  1489.      * Set attr values
  1490.      *
  1491.      * @param array $value Value
  1492.      *
  1493.      * @return void
  1494.      */
  1495.     public function setAttrValues($value)
  1496.     {
  1497.         $this->attrValues = $value;
  1498.     }
  1500.     /**
  1501.      * Sort editable attributes
  1502.      *
  1503.      * @param array $a Attribute A
  1504.      * @param array $b Attribute B
  1505.      *
  1506.      * @return int
  1507.      */
  1508.     protected function sortEditableAttributes($a, $b)
  1509.     {
  1510.         return $a['position'] > $b['position'] ? 1 : -1;
  1511.     }
  1513.     /**
  1514.      * Get editable attributes
  1515.      *
  1516.      * @return list<\XLite\Model\Attribute>
  1517.      */
  1518.     public function getEditableAttributes()
  1519.     {
  1520.         return $this->executeCachedRuntime(function () {
  1521.             return $this->defineEditableAttributes();
  1522.         }, ['getEditableAttributes', $this->getProductId()]);
  1523.     }
  1525.     public function sortMyAttributes(array $attributes): array
  1526.     {
  1527.         /** @var \XLite\Model\Attribute $attribute */
  1528.         $minPos = array_reduce($attributes, fn ($carry, $attribute) => max($carry, $attribute->getPosition($this)), 0);
  1529.         if ($minPos !== 0) {
  1530.             // at least one of them has non-default position
  1531.             usort($attributes, [$this, 'sortVisibleAttributes']);
  1532.         } else {
  1533.             usort($attributes, [$this, 'sortVisibleAttributesByGroup']);
  1534.         }
  1536.         return $attributes;
  1537.     }
  1539.     /**
  1540.      * @return array
  1541.      */
  1542.     protected function defineEditableAttributes()
  1543.     {
  1544.         $result = [];
  1546.         foreach ((array) \XLite\Model\Attribute::getTypes() as $type => $name) {
  1547.             $class = \XLite\Model\Attribute::getAttributeValueClass($type);
  1548.             if (is_subclass_of($class, 'XLite\Model\AttributeValue\Multiple')) {
  1549.                 $result[] = \XLite\Core\Database::getRepo($class)->findMultipleAttributes($this);
  1550.             } elseif ($class === '\XLite\Model\AttributeValue\AttributeValueText') {
  1551.                 $result[] = \XLite\Core\Database::getRepo($class)->findEditableAttributes($this);
  1552.             }
  1553.         }
  1555.         $result = (array) call_user_func_array('array_merge', $result);
  1556.         usort($result, [$this, 'sortEditableAttributes']);
  1558.         if ($result) {
  1559.             foreach ($result as $k => $v) {
  1560.                 $result[$k] = $v[0];
  1561.             }
  1562.         }
  1564.         return $result;
  1565.     }
  1567.     /**
  1568.      * Sort visible attributes
  1569.      *
  1570.      * @param \XLite\Model\Attribute $a Attribute A
  1571.      * @param \XLite\Model\Attribute $b Attribute B
  1572.      *
  1573.      * @return int
  1574.      */
  1575.     protected function sortVisibleAttributes($a, $b)
  1576.     {
  1577.         // fallback0 to product specific
  1578.         $aProductSpecific = $a->getPosition($this);
  1579.         $bProductSpecific = $b->getPosition($this);
  1581.         if ($aProductSpecific !== $bProductSpecific) {
  1582.             return $aProductSpecific <=> $bProductSpecific;
  1583.         }
  1585.         // fallback1 to global ordering
  1586.         $aGlobal = $a->getPosition();
  1587.         $bGlobal = $b->getPosition();
  1589.         if ($aGlobal !== $bGlobal) {
  1590.             return $aGlobal <=> $bGlobal;
  1591.         }
  1593.         // fallback2 to database insert ordering
  1594.         return $a->getId() <=> $b->getId();
  1595.     }
  1597.     /**
  1598.      * Sort visible attributes when all of them have default position
  1599.      */
  1600.     protected function sortVisibleAttributesByGroup(\XLite\Model\Attribute $a, \XLite\Model\Attribute $b): int
  1601.     {
  1602.         // Firstly, compare IDs only to avoid Hydration from database
  1603.         $aGroupId = $a->getAttributeGroup()?->getId() ?: 0;
  1604.         $bGroupId = $b->getAttributeGroup()?->getId() ?: 0;
  1606.         if ($aGroupId !== $bGroupId) {
  1607.             // Group IDs are not the same therefore we have no choice except hydration
  1608.             $aGroupPosition = $a->getAttributeGroup()?->getPosition() ?: $aGroupId;
  1609.             $bGroupPosition = $b->getAttributeGroup()?->getPosition() ?: $bGroupId;
  1611.             if ($aGroupPosition !== $bGroupPosition) {
  1612.                 return $aGroupPosition <=> $bGroupPosition;
  1613.             }
  1614.         }
  1616.         // fallback1 to global ordering
  1617.         $aGlobal = $a->getPosition();
  1618.         $bGlobal = $b->getPosition();
  1620.         if ($aGlobal !== $bGlobal) {
  1621.             return $aGlobal <=> $bGlobal;
  1622.         }
  1624.         // fallback2 to database insert ordering
  1625.         return $a->getId() <=> $b->getId();
  1626.     }
  1628.     /**
  1629.      * Get all visible attributes with values
  1630.      *
  1631.      * @return list<\XLite\Model\Attribute>
  1632.      */
  1633.     public function getVisibleAttributes()
  1634.     {
  1635.         return $this->executeCachedRuntime(function () {
  1636.             return $this->defineVisibleAttributes();
  1637.         }, ['getVisibleAttributes', $this->getProductId()]);
  1638.     }
  1640.     /**
  1641.      * @return array
  1642.      */
  1643.     protected function defineVisibleAttributes()
  1644.     {
  1645.         $result = [];
  1647.         foreach ((array) \XLite\Model\Attribute::getTypes() as $type => $name) {
  1648.             if ($type === \XLite\Model\Attribute::TYPE_HIDDEN) {
  1649.                 continue;
  1650.             }
  1652.             $result = array_merge(
  1653.                 $result,
  1654.                 \XLite\Core\Database::getRepo('XLite\Model\Attribute')
  1655.                     ->getAttributesWithValues($this, $type)
  1656.             );
  1657.         }
  1659.         return $this->sortMyAttributes($result);
  1660.     }
  1662.     /**
  1663.      * Check - product has visible attrbiutes or not
  1664.      *
  1665.      * @return boolean
  1666.      */
  1667.     public function hasVisibleAttributes()
  1668.     {
  1669.         return 0 < count($this->getVisibleAttributes());
  1670.     }
  1672.     /**
  1673.      * Get editable attributes ids
  1674.      *
  1675.      * @return array
  1676.      */
  1677.     public function getEditableAttributesIds()
  1678.     {
  1679.         $result = [];
  1681.         foreach ($this->getEditableAttributes() as $a) {
  1682.             $result[] = $a->getId();
  1683.         }
  1684.         sort($result);
  1686.         return $result;
  1687.     }
  1689.     /**
  1690.      * Check - product has editable attrbiutes or not
  1691.      *
  1692.      * @return boolean
  1693.      */
  1694.     public function hasEditableAttributes()
  1695.     {
  1696.         return 0 < count($this->getEditableAttributes());
  1697.     }
  1699.     /**
  1700.      * Get multiple attributes
  1701.      *
  1702.      * @return array
  1703.      */
  1704.     public function getMultipleAttributes()
  1705.     {
  1706.         $result = [];
  1708.         foreach (\XLite\Model\Attribute::getTypes() as $type => $name) {
  1709.             $class = \XLite\Model\Attribute::getAttributeValueClass($type);
  1710.             if (is_subclass_of($class, 'XLite\Model\AttributeValue\Multiple')) {
  1711.                 $result = array_merge(
  1712.                     $result,
  1713.                     \XLite\Core\Database::getRepo($class)->findMultipleAttributes($this)
  1714.                 );
  1715.             }
  1716.         }
  1718.         if ($result) {
  1719.             foreach ($result as $k => $v) {
  1720.                 $result[$k] = $v[0];
  1721.             }
  1722.         }
  1724.         return $result;
  1725.     }
  1727.     /**
  1728.      * Get multiple attributes ids
  1729.      *
  1730.      * @return array
  1731.      */
  1732.     public function getMultipleAttributesIds()
  1733.     {
  1734.         $result = [];
  1736.         foreach ($this->getMultipleAttributes() as $a) {
  1737.             $result[] = $a->getId();
  1738.         }
  1739.         sort($result);
  1741.         return $result;
  1742.     }
  1744.     /**
  1745.      * Check - product has multiple attributes or not
  1746.      *
  1747.      * @return boolean
  1748.      */
  1749.     public function hasMultipleAttributes()
  1750.     {
  1751.         return 0 < count($this->getMultipleAttributes());
  1752.     }
  1754.     /**
  1755.      * Update quick data
  1756.      *
  1757.      * @return void
  1758.      */
  1759.     public function updateQuickData()
  1760.     {
  1761.         if ($this->isPersistent()) {
  1762.             \XLite\Core\QuickData::getInstance()->updateProductData($this);
  1763.         }
  1764.     }
  1766.     /**
  1767.      * @return boolean
  1768.      */
  1769.     protected function showPlaceholderOption()
  1770.     {
  1771.         if (\XLite::isAdminZone()) {
  1772.             return false;
  1773.         } elseif (\XLite\Core\Config::getInstance()->General->force_choose_product_options === 'quicklook') {
  1774.             return \XLite::getController()->getTarget() !== 'product';
  1775.         } elseif (\XLite\Core\Config::getInstance()->General->force_choose_product_options === 'product_page') {
  1776.             return true;
  1777.         }
  1779.         return false;
  1780.     }
  1782.     /**
  1783.      * Prepare attribute values
  1784.      *
  1785.      * @param array $ids Request-based selected attribute values OPTIONAL
  1786.      *
  1787.      * @return array
  1788.      */
  1789.     public function prepareAttributeValues($ids = [])
  1790.     {
  1791.         return $this->executeCachedRuntime(function () use ($ids) {
  1792.             $attributeValues = [];
  1793.             foreach ($this->getEditableAttributes() as $a) {
  1794.                 if ($a->getType() === \XLite\Model\Attribute::TYPE_TEXT) {
  1795.                     $value     = $ids[$a->getId()] ?? $a->getAttributeValue($this)->getValue();
  1796.                     $attrValue = $a->getAttributeValue($this);
  1798.                     $attributeValues[$a->getId()] = [
  1799.                         'attributeValue' => $attrValue,
  1800.                         'value'          => $value,
  1801.                     ];
  1802.                 } elseif ($a->getType() === \XLite\Model\Attribute::TYPE_CHECKBOX) {
  1803.                     $found = null;
  1805.                     if (isset($ids[$a->getId()])) {
  1806.                         foreach ($a->getAttributeValue($this) as $av) {
  1807.                             if ($av->getId() === (int) $ids[$a->getId()]) {
  1808.                                 $found = $av;
  1809.                                 break;
  1810.                             }
  1811.                         }
  1812.                     }
  1814.                     $value = $found ?: $a->getDefaultAttributeValue($this);
  1815.                     $attributeValues[$a->getId()] = $value;
  1816.                 } else {
  1817.                     if (!$this->showPlaceholderOption()) {
  1818.                         $attributeValues[$a->getId()] = $a->getDefaultAttributeValue($this);
  1819.                     }
  1821.                     if (isset($ids[$a->getId()])) {
  1822.                         foreach ($a->getAttributeValue($this) as $av) {
  1823.                             if ($av->getId() === (int) $ids[$a->getId()]) {
  1824.                                 $attributeValues[$a->getId()] = $av;
  1825.                                 break;
  1826.                             }
  1827.                         }
  1828.                     }
  1829.                 }
  1830.             }
  1832.             return $attributeValues;
  1833.         }, ['prepareAttributeValues', $ids]);
  1834.     }
  1836.     /**
  1837.      * Define the specific clone name for the product
  1838.      *
  1839.      * @param string $name Product name
  1840.      *
  1841.      * @return string
  1842.      */
  1843.     protected function getCloneName($name)
  1844.     {
  1845.         return $name . ' [ clone ]';
  1846.     }
  1848.     /**
  1849.      * Preprocess change product class
  1850.      *
  1851.      * @return void
  1852.      */
  1853.     protected function preprocessChangeProductClass()
  1854.     {
  1855.         if ($this->productClass) {
  1856.             foreach ($this->productClass->getAttributes() as $a) {
  1857.                 $class = $a->getAttributeValueClass($a->getType());
  1858.                 $repo  = \XLite\Core\Database::getRepo($class);
  1859.                 foreach ($repo->findBy(['product' => $this, 'attribute' => $a]) as $v) {
  1860.                     $repo->delete($v);
  1861.                 }
  1862.             }
  1863.         }
  1864.     }
  1866.     /**
  1867.      * Return certain Product <--> Category association
  1868.      *
  1869.      * @param integer|null $categoryId Category ID
  1870.      *
  1871.      * @return \XLite\Model\CategoryProducts|void
  1872.      */
  1873.     protected function findLinkByCategoryId($categoryId)
  1874.     {
  1875.         $result = null;
  1877.         foreach ($this->getCategoryProducts() as $cp) {
  1878.             if ($cp->getCategory() && $cp->getCategory()->getCategoryId() == $categoryId) {
  1879.                 $result = $cp;
  1880.             }
  1881.         }
  1883.         return $result;
  1884.     }
  1886.     /**
  1887.      * Return certain Product <--> Category association
  1888.      *
  1889.      * @param integer|null $categoryId Category ID OPTIONAL
  1890.      *
  1891.      * @return \XLite\Model\CategoryProducts
  1892.      */
  1893.     protected function getLink($categoryId = null)
  1894.     {
  1895.         $result = empty($categoryId)
  1896.             ? $this->getCategoryProducts()->first()
  1897.             : $this->findLinkByCategoryId($categoryId);
  1899.         if (empty($result)) {
  1900.             $result = new \XLite\Model\CategoryProducts();
  1901.         }
  1903.         return $result;
  1904.     }
  1906.     /**
  1907.      * Returns position of the product in the given category
  1908.      *
  1909.      * @param integer $category
  1910.      *
  1911.      * @return integer
  1912.      */
  1913.     public function getPosition($category)
  1914.     {
  1915.         return $this->getOrderBy($category);
  1916.     }
  1918.     /**
  1919.      * Sets the position of the product in the given category
  1920.      *
  1921.      * @param array $value
  1922.      *
  1923.      * @return void
  1924.      */
  1925.     public function setPosition($value)
  1926.     {
  1927.         $link = $this->getLink($value['category']);
  1928.         $link->setProduct($this);
  1929.         $link->setOrderby($value['position']);
  1931.         \XLite\Core\Database::getEM()->persist($link);
  1932.         \XLite\Core\Database::getEM()->flush($link);
  1933.     }
  1935.     /**
  1936.      * Returns meta description
  1937.      *
  1938.      * @return string
  1939.      */
  1940.     public function getMetaDesc()
  1941.     {
  1942.         return $this->getMetaDescType() === static::META_DESC_TYPE_AUTO
  1943.             ? static::generateMetaDescription($this->getCommonDescription())
  1944.             : $this->getSoftTranslation()->getMetaDesc();
  1945.     }
  1947.     /**
  1948.      * Generate meta description
  1949.      *
  1950.      * @param $description
  1951.      *
  1952.      * @return string
  1953.      */
  1954.     public static function generateMetaDescription($description)
  1955.     {
  1956.         return static::postprocessMetaDescription($description);
  1957.     }
  1959.     /**
  1960.      * Returns meta description type
  1961.      *
  1962.      * @return string
  1963.      */
  1964.     public function getMetaDescType()
  1965.     {
  1966.         $result = $this->metaDescType;
  1968.         if (!$result) {
  1969.             $metaDescPresent = array_reduce($this->getTranslations()->toArray(), static function ($carry, $item) {
  1970.                 return $carry ?: (bool) $item->getMetaDesc();
  1971.             }, false);
  1973.             $result = $metaDescPresent
  1974.                 ? static::META_DESC_TYPE_CUSTOM
  1975.                 : static::META_DESC_TYPE_AUTO;
  1976.         }
  1978.         return $result;
  1979.     }
  1981.     // {{{ Sales statistics
  1983.     /**
  1984.      * Set sales
  1985.      *
  1986.      * @param integer $sales Sales
  1987.      */
  1988.     public function setSales($sales)
  1989.     {
  1990.         $this->sales = max(0, $sales);
  1991.     }
  1993.     /**
  1994.      * Return sales
  1995.      *
  1996.      * @return integer
  1997.      */
  1998.     public function getSales()
  1999.     {
  2000.         return $this->sales;
  2001.     }
  2003.     /**
  2004.      * Update sales
  2005.      */
  2006.     public function updateSales()
  2007.     {
  2008.         $this->setSales(
  2009.             $this->getRepository()->findSalesByProduct($this)
  2010.         );
  2011.     }
  2013.     // }}}
  2015.     /**
  2016.      * Get product_id
  2017.      *
  2018.      * @return integer
  2019.      */
  2020.     public function getProductId()
  2021.     {
  2022.         return $this->product_id;
  2023.     }
  2025.     /**
  2026.      * Set price
  2027.      *
  2028.      * @param float $price
  2029.      *
  2030.      * @return Product
  2031.      */
  2032.     public function setPrice($price)
  2033.     {
  2034.         $this->price = Converter::toUnsigned32BitFloat($price);
  2036.         return $this;
  2037.     }
  2039.     /**
  2040.      * Set enabled
  2041.      *
  2042.      * @param boolean $enabled
  2043.      *
  2044.      * @return Product
  2045.      */
  2046.     public function setEnabled($enabled)
  2047.     {
  2048.         $this->enabled = (bool) $enabled;
  2050.         return $this;
  2051.     }
  2053.     /**
  2054.      * Get enabled
  2055.      *
  2056.      * @return boolean
  2057.      */
  2058.     public function getEnabled()
  2059.     {
  2060.         return $this->enabled;
  2061.     }
  2063.     /**
  2064.      * Set weight
  2065.      *
  2066.      * @param float $weight
  2067.      *
  2068.      * @return Product
  2069.      */
  2070.     public function setWeight($weight)
  2071.     {
  2072.         $this->weight = Converter::toUnsigned32BitFloat($weight);
  2074.         return $this;
  2075.     }
  2077.     /**
  2078.      * Set useSeparateBox
  2079.      *
  2080.      * @param boolean $useSeparateBox
  2081.      *
  2082.      * @return Product
  2083.      */
  2084.     public function setUseSeparateBox($useSeparateBox)
  2085.     {
  2086.         $this->useSeparateBox = $useSeparateBox;
  2088.         return $this;
  2089.     }
  2091.     /**
  2092.      * Get useSeparateBox
  2093.      *
  2094.      * @return boolean
  2095.      */
  2096.     public function getUseSeparateBox()
  2097.     {
  2098.         return $this->useSeparateBox;
  2099.     }
  2101.     /**
  2102.      * Set boxWidth
  2103.      *
  2104.      * @param float $boxWidth
  2105.      *
  2106.      * @return Product
  2107.      */
  2108.     public function setBoxWidth($boxWidth)
  2109.     {
  2110.         $this->boxWidth = Converter::toUnsigned32BitFloat($boxWidth);
  2112.         return $this;
  2113.     }
  2115.     /**
  2116.      * Get boxWidth
  2117.      *
  2118.      * @return float
  2119.      */
  2120.     public function getBoxWidth()
  2121.     {
  2122.         return $this->boxWidth;
  2123.     }
  2125.     /**
  2126.      * Set boxLength
  2127.      *
  2128.      * @param float $boxLength
  2129.      *
  2130.      * @return Product
  2131.      */
  2132.     public function setBoxLength($boxLength)
  2133.     {
  2134.         $this->boxLength = Converter::toUnsigned32BitFloat($boxLength);
  2136.         return $this;
  2137.     }
  2139.     /**
  2140.      * Get boxLength
  2141.      *
  2142.      * @return float
  2143.      */
  2144.     public function getBoxLength()
  2145.     {
  2146.         return $this->boxLength;
  2147.     }
  2149.     /**
  2150.      * Set boxHeight
  2151.      *
  2152.      * @param float $boxHeight
  2153.      *
  2154.      * @return Product
  2155.      */
  2156.     public function setBoxHeight($boxHeight)
  2157.     {
  2158.         $this->boxHeight = Converter::toUnsigned32BitFloat($boxHeight);
  2160.         return $this;
  2161.     }
  2163.     /**
  2164.      * Get boxHeight
  2165.      *
  2166.      * @return float
  2167.      */
  2168.     public function getBoxHeight()
  2169.     {
  2170.         return $this->boxHeight;
  2171.     }
  2173.     /**
  2174.      * Set itemsPerBox
  2175.      *
  2176.      * @param integer $itemsPerBox
  2177.      *
  2178.      * @return Product
  2179.      */
  2180.     public function setItemsPerBox($itemsPerBox)
  2181.     {
  2182.         $this->itemsPerBox = Converter::toUnsigned32BitInt($itemsPerBox);
  2184.         return $this;
  2185.     }
  2187.     /**
  2188.      * Get itemsPerBox
  2189.      *
  2190.      * @return integer
  2191.      */
  2192.     public function getItemsPerBox()
  2193.     {
  2194.         return $this->itemsPerBox;
  2195.     }
  2197.     /**
  2198.      * Set free_shipping
  2199.      *
  2200.      * @param boolean $freeShipping
  2201.      *
  2202.      * @return Product
  2203.      */
  2204.     public function setFreeShipping($freeShipping)
  2205.     {
  2206.         $this->free_shipping = (bool) $freeShipping;
  2208.         return $this;
  2209.     }
  2211.     /**
  2212.      * Set taxable
  2213.      *
  2214.      * @param boolean $taxable
  2215.      *
  2216.      * @return Product
  2217.      */
  2218.     public function setTaxable($taxable)
  2219.     {
  2220.         $this->taxable = $taxable;
  2222.         return $this;
  2223.     }
  2225.     /**
  2226.      * Get taxable
  2227.      *
  2228.      * @return boolean
  2229.      */
  2230.     public function getTaxable()
  2231.     {
  2232.         return $this->taxable;
  2233.     }
  2235.     /**
  2236.      * Set arrivalDate
  2237.      *
  2238.      * @param integer $arrivalDate
  2239.      *
  2240.      * @return Product
  2241.      */
  2242.     public function setArrivalDate($arrivalDate)
  2243.     {
  2244.         $this->arrivalDate = min(MAX_TIMESTAMP, max(0, $arrivalDate));
  2246.         return $this;
  2247.     }
  2249.     /**
  2250.      * Get arrivalDate
  2251.      *
  2252.      * @return integer
  2253.      */
  2254.     public function getArrivalDate()
  2255.     {
  2256.         return $this->arrivalDate;
  2257.     }
  2259.     /**
  2260.      * Returns true if product is classified as an upcoming product
  2261.      *
  2262.      * @return boolean
  2263.      */
  2264.     public function isUpcomingProduct()
  2265.     {
  2266.         return $this->getArrivalDate()
  2267.             && $this->getArrivalDate() > Converter::getDayEnd(static::getUserTime());
  2268.     }
  2270.     /**
  2271.      * Check if upcoming product is available
  2272.      *
  2273.      * @return boolean
  2274.      */
  2275.     public function isAllowedUpcomingProduct()
  2276.     {
  2277.         return false;
  2278.     }
  2280.     /**
  2281.      * Set date
  2282.      *
  2283.      * @param integer $date
  2284.      *
  2285.      * @return Product
  2286.      */
  2287.     public function setDate($date)
  2288.     {
  2289.         $this->date = $date;
  2291.         return $this;
  2292.     }
  2294.     /**
  2295.      * Get date
  2296.      *
  2297.      * @return integer
  2298.      */
  2299.     public function getDate()
  2300.     {
  2301.         return $this->date;
  2302.     }
  2304.     /**
  2305.      * Set updateDate
  2306.      *
  2307.      * @param integer $updateDate
  2308.      *
  2309.      * @return Product
  2310.      */
  2311.     public function setUpdateDate($updateDate)
  2312.     {
  2313.         $this->updateDate = $updateDate;
  2315.         return $this;
  2316.     }
  2318.     /**
  2319.      * Get updateDate
  2320.      *
  2321.      * @return integer
  2322.      */
  2323.     public function getUpdateDate()
  2324.     {
  2325.         return $this->updateDate;
  2326.     }
  2328.     /**
  2329.      * Set needProcess
  2330.      *
  2331.      * @param boolean $needProcess
  2332.      *
  2333.      * @return Product
  2334.      */
  2335.     public function setNeedProcess($needProcess)
  2336.     {
  2337.         $this->needProcess = $needProcess;
  2339.         return $this;
  2340.     }
  2342.     /**
  2343.      * Get needProcess
  2344.      *
  2345.      * @return boolean
  2346.      */
  2347.     public function getNeedProcess()
  2348.     {
  2349.         return $this->needProcess;
  2350.     }
  2352.     /**
  2353.      * Set attrSepTab
  2354.      *
  2355.      * @param boolean $attrSepTab
  2356.      *
  2357.      * @return Product
  2358.      */
  2359.     public function setAttrSepTab($attrSepTab)
  2360.     {
  2361.         $this->attrSepTab = $attrSepTab;
  2363.         return $this;
  2364.     }
  2366.     /**
  2367.      * Get attrSepTab
  2368.      *
  2369.      * @return boolean
  2370.      */
  2371.     public function getAttrSepTab()
  2372.     {
  2373.         return $this->attrSepTab;
  2374.     }
  2376.     /**
  2377.      * Set metaDescType
  2378.      *
  2379.      * @param string $metaDescType
  2380.      *
  2381.      * @return Product
  2382.      */
  2383.     public function setMetaDescType($metaDescType)
  2384.     {
  2385.         $this->metaDescType = $metaDescType;
  2387.         return $this;
  2388.     }
  2390.     /**
  2391.      * Set xcPendingExport
  2392.      *
  2393.      * @param boolean $xcPendingExport
  2394.      *
  2395.      * @return Product
  2396.      */
  2397.     public function setXcPendingExport($xcPendingExport)
  2398.     {
  2399.         $this->xcPendingExport = $xcPendingExport;
  2401.         return $this;
  2402.     }
  2404.     /**
  2405.      * Get xcPendingExport
  2406.      *
  2407.      * @return boolean
  2408.      */
  2409.     public function getXcPendingExport()
  2410.     {
  2411.         return $this->xcPendingExport;
  2412.     }
  2414.     /**
  2415.      * Add categoryProducts
  2416.      *
  2417.      * @param \XLite\Model\CategoryProducts $categoryProducts
  2418.      *
  2419.      * @return Product
  2420.      */
  2421.     public function addCategoryProducts(\XLite\Model\CategoryProducts $categoryProducts)
  2422.     {
  2423.         $this->categoryProducts[] = $categoryProducts;
  2425.         return $this;
  2426.     }
  2428.     /**
  2429.      * Get categoryProducts
  2430.      *
  2431.      * @return \Doctrine\Common\Collections\Collection
  2432.      */
  2433.     public function getCategoryProducts()
  2434.     {
  2435.         return $this->categoryProducts;
  2436.     }
  2438.     /**
  2439.      * @param \XLite\Model\Category[] $categories
  2440.      */
  2441.     public function addCategoryProductsLinksByCategories($categories)
  2442.     {
  2443.         foreach ($categories as $category) {
  2444.             if (!$this->hasCategoryProductsLinkByCategory($category)) {
  2445.                 $categoryProduct = new \XLite\Model\CategoryProducts();
  2446.                 $categoryProduct->setProduct($this);
  2447.                 $categoryProduct->setCategory($category);
  2449.                 $this->addCategoryProducts($categoryProduct);
  2450.             }
  2451.         }
  2452.     }
  2454.     /**
  2455.      * @param \XLite\Model\Category $category
  2456.      */
  2457.     public function addCategory($category)
  2458.     {
  2459.         $categoryProduct = new \XLite\Model\CategoryProducts();
  2460.         $categoryProduct->setProduct($this);
  2461.         $categoryProduct->setCategory($category);
  2463.         $this->addCategoryProducts($categoryProduct);
  2464.     }
  2466.     /**
  2467.      * @param \XLite\Model\Category[] $categories
  2468.      */
  2469.     public function removeCategoryProductsLinksByCategories($categories)
  2470.     {
  2471.         $categoryProductsLinks = [];
  2473.         foreach ($categories as $category) {
  2474.             $categoryProductsLink = $this->findCategoryProductsLinkByCategory($category);
  2475.             if ($categoryProductsLink) {
  2476.                 $categoryProductsLinks[] = $categoryProductsLink;
  2477.             }
  2478.         }
  2480.         if ($categoryProductsLinks) {
  2481.             \XLite\Core\Database::getRepo('XLite\Model\CategoryProducts')->deleteInBatch(
  2482.                 $categoryProductsLinks
  2483.             );
  2484.         }
  2485.     }
  2487.     /**
  2488.      * @param \XLite\Model\Category[] $categories
  2489.      */
  2490.     public function replaceCategoryProductsLinksByCategories($categories)
  2491.     {
  2492.         $categoriesToAdd = [];
  2493.         foreach ($categories as $category) {
  2494.             if (!$this->hasCategoryProductsLinkByCategory($category)) {
  2495.                 $categoriesToAdd[] = $category;
  2496.             }
  2497.         }
  2499.         $categoriesIds = array_map(static function ($item) {
  2500.             /** @var \XLite\Model\Category $item */
  2501.             return (int) $item->getCategoryId();
  2502.         }, $categories);
  2504.         $categoryProductsLinksToDelete = [];
  2505.         foreach ($this->getCategoryProducts() as $categoryProduct) {
  2506.             if (!in_array((int) $categoryProduct->getCategory()->getCategoryId(), $categoriesIds, true)) {
  2507.                 $categoryProductsLinksToDelete[] = $categoryProduct;
  2508.             }
  2509.         }
  2511.         if ($categoryProductsLinksToDelete) {
  2512.             \XLite\Core\Database::getRepo('XLite\Model\CategoryProducts')->deleteInBatch(
  2513.                 $categoryProductsLinksToDelete
  2514.             );
  2515.         }
  2517.         if ($categoriesToAdd) {
  2518.             $this->addCategoryProductsLinksByCategories($categoriesToAdd);
  2519.         }
  2520.     }
  2522.     /**
  2523.      * @param \XLite\Model\Category $category
  2524.      *
  2525.      * @return bool
  2526.      */
  2527.     public function hasCategoryProductsLinkByCategory($category)
  2528.     {
  2529.         return (bool) $this->findCategoryProductsLinkByCategory($category);
  2530.     }
  2532.     /**
  2533.      * @param \XLite\Model\Category $category
  2534.      *
  2535.      * @return \XLite\Model\CategoryProducts
  2536.      */
  2537.     public function findCategoryProductsLinkByCategory($category)
  2538.     {
  2539.         /** @var \XLite\Model\CategoryProducts $categoryProduct */
  2540.         foreach ($this->getCategoryProducts() as $categoryProduct) {
  2541.             if ((int) $categoryProduct->getCategory()->getCategoryId() === (int) $category->getCategoryId()) {
  2542.                 return $categoryProduct;
  2543.             }
  2544.         }
  2546.         return null;
  2547.     }
  2549.     /**
  2550.      * Add order_items
  2551.      *
  2552.      * @param \XLite\Model\OrderItem $orderItems
  2553.      *
  2554.      * @return Product
  2555.      */
  2556.     public function addOrderItems(\XLite\Model\OrderItem $orderItems)
  2557.     {
  2558.         $this->order_items[] = $orderItems;
  2560.         return $this;
  2561.     }
  2563.     /**
  2564.      * Get order_items
  2565.      *
  2566.      * @return \Doctrine\Common\Collections\Collection
  2567.      */
  2568.     public function getOrderItems()
  2569.     {
  2570.         return $this->order_items;
  2571.     }
  2573.     /**
  2574.      * Add images
  2575.      *
  2576.      * @param \XLite\Model\Image\Product\Image $images
  2577.      *
  2578.      * @return Product
  2579.      */
  2580.     public function addImages(\XLite\Model\Image\Product\Image $images)
  2581.     {
  2582.         $this->images[] = $images;
  2584.         return $this;
  2585.     }
  2587.     /**
  2588.      * Get images
  2589.      *
  2590.      * @return \Doctrine\Common\Collections\Collection
  2591.      */
  2592.     public function getImages()
  2593.     {
  2594.         return $this->images;
  2595.     }
  2597.     /**
  2598.      * Get productClass
  2599.      *
  2600.      * @return \XLite\Model\ProductClass
  2601.      */
  2602.     public function getProductClass()
  2603.     {
  2604.         return $this->productClass;
  2605.     }
  2607.     /**
  2608.      * Set taxClass
  2609.      *
  2610.      * @param \XLite\Model\TaxClass $taxClass
  2611.      *
  2612.      * @return Product
  2613.      */
  2614.     public function setTaxClass(\XLite\Model\TaxClass $taxClass = null)
  2615.     {
  2616.         $this->taxClass = $taxClass;
  2618.         return $this;
  2619.     }
  2621.     /**
  2622.      * Get taxClass
  2623.      *
  2624.      * @return \XLite\Model\TaxClass
  2625.      */
  2626.     public function getTaxClass()
  2627.     {
  2628.         return $this->taxClass;
  2629.     }
  2631.     /**
  2632.      * Add attributes
  2633.      *
  2634.      * @param \XLite\Model\Attribute $attributes
  2635.      *
  2636.      * @return Product
  2637.      */
  2638.     public function addAttributes(\XLite\Model\Attribute $attributes)
  2639.     {
  2640.         $this->attributes[] = $attributes;
  2642.         return $this;
  2643.     }
  2645.     /**
  2646.      * Get attributes
  2647.      *
  2648.      * @return \Doctrine\Common\Collections\Collection<int, \XLite\Model\Attribute>
  2649.      */
  2650.     public function getAttributes()
  2651.     {
  2652.         return $this->attributes;
  2653.     }
  2655.     /**
  2656.      * Add attributeValueC
  2657.      *
  2658.      * @param \XLite\Model\AttributeValue\AttributeValueCheckbox $attributeValueC
  2659.      *
  2660.      * @return Product
  2661.      */
  2662.     public function addAttributeValueC(\XLite\Model\AttributeValue\AttributeValueCheckbox $attributeValueC)
  2663.     {
  2664.         $this->attributeValueC[] = $attributeValueC;
  2666.         return $this;
  2667.     }
  2669.     /**
  2670.      * Get attributeValueC
  2671.      *
  2672.      * @return \Doctrine\Common\Collections\Collection
  2673.      */
  2674.     public function getAttributeValueC()
  2675.     {
  2676.         return $this->attributeValueC;
  2677.     }
  2679.     /**
  2680.      * Add attributeValueT
  2681.      *
  2682.      * @param \XLite\Model\AttributeValue\AttributeValueText $attributeValueT
  2683.      *
  2684.      * @return Product
  2685.      */
  2686.     public function addAttributeValueT(\XLite\Model\AttributeValue\AttributeValueText $attributeValueT)
  2687.     {
  2688.         $this->attributeValueT[] = $attributeValueT;
  2690.         return $this;
  2691.     }
  2693.     /**
  2694.      * Get attributeValueT
  2695.      *
  2696.      * @return \Doctrine\Common\Collections\Collection
  2697.      */
  2698.     public function getAttributeValueT()
  2699.     {
  2700.         return $this->attributeValueT;
  2701.     }
  2703.     /**
  2704.      * Add attributeValueS
  2705.      *
  2706.      * @param \XLite\Model\AttributeValue\AttributeValueSelect $attributeValueS
  2707.      *
  2708.      * @return Product
  2709.      */
  2710.     public function addAttributeValueS(\XLite\Model\AttributeValue\AttributeValueSelect $attributeValueS)
  2711.     {
  2712.         $this->attributeValueS[] = $attributeValueS;
  2714.         return $this;
  2715.     }
  2717.     /**
  2718.      * Get attributeValueS
  2719.      *
  2720.      * @return \Doctrine\Common\Collections\Collection
  2721.      */
  2722.     public function getAttributeValueS()
  2723.     {
  2724.         return $this->attributeValueS;
  2725.     }
  2727.     /**
  2728.      * Add attributeValueH
  2729.      *
  2730.      * @param \XLite\Model\AttributeValue\AttributeValueHidden $attributeValueH
  2731.      *
  2732.      * @return Product
  2733.      */
  2734.     public function addAttributeValueH(\XLite\Model\AttributeValue\AttributeValueHidden $attributeValueH)
  2735.     {
  2736.         $this->attributeValueH[] = $attributeValueH;
  2738.         return $this;
  2739.     }
  2741.     /**
  2742.      * Get attributeValueH
  2743.      *
  2744.      * @return \Doctrine\Common\Collections\Collection
  2745.      */
  2746.     public function getAttributeValueH()
  2747.     {
  2748.         return $this->attributeValueH;
  2749.     }
  2751.     /**
  2752.      * Add quickData
  2753.      *
  2754.      * @param \XLite\Model\QuickData $quickData
  2755.      *
  2756.      * @return Product
  2757.      */
  2758.     public function addQuickData(\XLite\Model\QuickData $quickData)
  2759.     {
  2760.         $this->quickData[] = $quickData;
  2762.         return $this;
  2763.     }
  2765.     /**
  2766.      * Get quickData
  2767.      *
  2768.      * @return \Doctrine\Common\Collections\Collection
  2769.      */
  2770.     public function getQuickData()
  2771.     {
  2772.         return $this->quickData;
  2773.     }
  2775.     /**
  2776.      * Add memberships
  2777.      *
  2778.      * @param \XLite\Model\Membership $memberships
  2779.      *
  2780.      * @return Product
  2781.      */
  2782.     public function addMemberships(\XLite\Model\Membership $memberships)
  2783.     {
  2784.         $this->memberships[] = $memberships;
  2786.         return $this;
  2787.     }
  2789.     /**
  2790.      * Get memberships
  2791.      *
  2792.      * @return \Doctrine\Common\Collections\Collection
  2793.      */
  2794.     public function getMemberships()
  2795.     {
  2796.         return $this->memberships;
  2797.     }
  2799.     /**
  2800.      * @param \XLite\Model\Membership[] $memberships
  2801.      */
  2802.     public function addMembershipsByMemberships($memberships)
  2803.     {
  2804.         foreach ($memberships as $membership) {
  2805.             if (!$this->hasMembershipByMembership($membership)) {
  2806.                 $this->addMemberships($membership);
  2807.             }
  2808.         }
  2809.     }
  2811.     /**
  2812.      * @param \XLite\Model\Membership[] $memberships
  2813.      */
  2814.     public function removeMembershipsByMemberships($memberships)
  2815.     {
  2816.         foreach ($memberships as $membership) {
  2817.             if ($this->hasMembershipByMembership($membership)) {
  2818.                 $this->getMemberships()->removeElement($membership);
  2819.             }
  2820.         }
  2821.     }
  2823.     /**
  2824.      * @param \XLite\Model\Membership[] $memberships
  2825.      */
  2826.     public function replaceMembershipsByMemberships($memberships)
  2827.     {
  2828.         $ids = array_map(static function ($item) {
  2829.             /** @var \XLite\Model\Membership $item */
  2830.             return (int) $item->getMembershipId();
  2831.         }, $memberships);
  2833.         $toRemove = [];
  2834.         foreach ($this->getMemberships() as $membership) {
  2835.             if (!in_array((int) $membership->getMembershipId(), $ids, true)) {
  2836.                 $toRemove[] = $membership;
  2837.             }
  2838.         }
  2840.         $this->addMembershipsByMemberships($memberships);
  2841.         $this->removeMembershipsByMemberships($toRemove);
  2842.     }
  2844.     /**
  2845.      * @param \XLite\Model\Membership $membership
  2846.      *
  2847.      * @return boolean
  2848.      */
  2849.     public function hasMembershipByMembership($membership)
  2850.     {
  2851.         return (bool) $this->getMembershipByMembership($membership);
  2852.     }
  2854.     /**
  2855.      * @param \XLite\Model\Membership $membership
  2856.      *
  2857.      * @return mixed|null
  2858.      */
  2859.     public function getMembershipByMembership($membership)
  2860.     {
  2861.         foreach ($this->getMemberships() as $membershipObject) {
  2862.             if (
  2863.                 (
  2864.                     $membership->isPersistent()
  2865.                     && (int) $membership->getMembershipId() === (int) $membershipObject->getMembershipId()
  2866.                 )
  2867.                 || $membership === $membershipObject
  2868.             ) {
  2869.                 return $membershipObject;
  2870.             }
  2871.         }
  2873.         return null;
  2874.     }
  2876.     /**
  2877.      * Add cleanURLs
  2878.      *
  2879.      * @param \XLite\Model\CleanURL $cleanURLs
  2880.      *
  2881.      * @return Product
  2882.      */
  2883.     public function addCleanURLs(\XLite\Model\CleanURL $cleanURLs)
  2884.     {
  2885.         $this->cleanURLs[] = $cleanURLs;
  2887.         return $this;
  2888.     }
  2890.     /**
  2891.      * Get cleanURLs
  2892.      *
  2893.      * @return \Doctrine\Common\Collections\Collection
  2894.      */
  2895.     public function getCleanURLs()
  2896.     {
  2897.         return $this->cleanURLs;
  2898.     }
  2900.     /**
  2901.      * Set inventoryEnabled
  2902.      *
  2903.      * @param boolean $inventoryEnabled
  2904.      *
  2905.      * @return Product
  2906.      */
  2907.     public function setInventoryEnabled($inventoryEnabled)
  2908.     {
  2909.         $this->inventoryEnabled = $inventoryEnabled;
  2911.         return $this;
  2912.     }
  2914.     /**
  2915.      * Get inventoryEnabled
  2916.      *
  2917.      * @return boolean
  2918.      */
  2919.     public function getInventoryEnabled()
  2920.     {
  2921.         return $this->inventoryEnabled;
  2922.     }
  2924.     /**
  2925.      * Get amount
  2926.      *
  2927.      * @return integer
  2928.      */
  2929.     public function getAmount()
  2930.     {
  2931.         return $this->amount;
  2932.     }
  2934.     /**
  2935.      * Set lowLimitEnabledCustomer
  2936.      *
  2937.      * @param boolean $lowLimitEnabledCustomer
  2938.      *
  2939.      * @return Product
  2940.      */
  2941.     public function setLowLimitEnabledCustomer($lowLimitEnabledCustomer)
  2942.     {
  2943.         $this->lowLimitEnabledCustomer = $lowLimitEnabledCustomer;
  2945.         return $this;
  2946.     }
  2948.     /**
  2949.      * Get lowLimitEnabledCustomer
  2950.      *
  2951.      * @return boolean
  2952.      */
  2953.     public function getLowLimitEnabledCustomer()
  2954.     {
  2955.         return $this->lowLimitEnabledCustomer;
  2956.     }
  2958.     /**
  2959.      * Set lowLimitEnabled
  2960.      *
  2961.      * @param boolean $lowLimitEnabled
  2962.      *
  2963.      * @return Product
  2964.      */
  2965.     public function setLowLimitEnabled($lowLimitEnabled)
  2966.     {
  2967.         $this->lowLimitEnabled = $lowLimitEnabled;
  2969.         return $this;
  2970.     }
  2972.     /**
  2973.      * Get lowLimitEnabled
  2974.      *
  2975.      * @return boolean
  2976.      */
  2977.     public function getLowLimitEnabled()
  2978.     {
  2979.         return $this->lowLimitEnabled;
  2980.     }
  2982.     /**
  2983.      * Get lowLimitAmount
  2984.      *
  2985.      * @return integer
  2986.      */
  2987.     public function getLowLimitAmount()
  2988.     {
  2989.         return $this->lowLimitAmount;
  2990.     }
  2992.     /**
  2993.      * @return integer
  2994.      */
  2995.     protected function getAvailableAmountForTooltipText()
  2996.     {
  2997.         return $this->getAvailableAmount();
  2998.     }
  3000.     /**
  3001.      * Get help text for "all stock in cart" product
  3002.      *
  3003.      * @return string
  3004.      */
  3005.     public function getAllStockInCartTooltipText()
  3006.     {
  3007.         $text = '';
  3009.         if ($this->getInventoryEnabled()) {
  3010.             $text = static::t(
  3011.                 'Sorry, we only have {{qty}} of that item available',
  3012.                 ['qty' => $this->getAvailableAmountForTooltipText()]
  3013.             );
  3014.         }
  3016.         return $text;
  3017.     }
  3019.     // {{{ Translation Getters / setters
  3021.     /**
  3022.      * @return string
  3023.      */
  3024.     public function getDescription()
  3025.     {
  3026.         return $this->getTranslationField(__FUNCTION__);
  3027.     }
  3029.     /**
  3030.      * @param string $description
  3031.      *
  3032.      * @return \XLite\Model\Base\Translation
  3033.      */
  3034.     public function setDescription($description)
  3035.     {
  3036.         return $this->setTranslationField(__FUNCTION__, $description);
  3037.     }
  3039.     /**
  3040.      * @return string
  3041.      */
  3042.     public function getBriefDescription()
  3043.     {
  3044.         return $this->getTranslationField(__FUNCTION__);
  3045.     }
  3047.     /**
  3048.      * @param string $briefDescription
  3049.      *
  3050.      * @return \XLite\Model\Base\Translation
  3051.      */
  3052.     public function setBriefDescription($briefDescription)
  3053.     {
  3054.         return $this->setTranslationField(__FUNCTION__, $briefDescription);
  3055.     }
  3057.     /**
  3058.      * @return string
  3059.      */
  3060.     public function getMetaTags()
  3061.     {
  3062.         return $this->getTranslationField(__FUNCTION__);
  3063.     }
  3065.     /**
  3066.      * @param string $metaTags
  3067.      *
  3068.      * @return \XLite\Model\Base\Translation
  3069.      */
  3070.     public function setMetaTags($metaTags)
  3071.     {
  3072.         return $this->setTranslationField(__FUNCTION__, $metaTags);
  3073.     }
  3075.     /**
  3076.      * @param string $metaDesc
  3077.      *
  3078.      * @return \XLite\Model\Base\Translation
  3079.      */
  3080.     public function setMetaDesc($metaDesc)
  3081.     {
  3082.         return $this->setTranslationField(__FUNCTION__, $metaDesc);
  3083.     }
  3085.     /**
  3086.      * @return string
  3087.      */
  3088.     public function getMetaTitle()
  3089.     {
  3090.         return $this->getTranslationField(__FUNCTION__);
  3091.     }
  3093.     /**
  3094.      * @param string $metaTitle
  3095.      *
  3096.      * @return \XLite\Model\Base\Translation
  3097.      */
  3098.     public function setMetaTitle($metaTitle)
  3099.     {
  3100.         return $this->setTranslationField(__FUNCTION__, $metaTitle);
  3101.     }
  3103.     // }}}
  3105.     public function isDemoProduct(): bool
  3106.     {
  3107.         return $this->isDemoProduct;
  3108.     }
  3110.     public function setIsDemoProduct(bool $isDemoProduct): self
  3111.     {
  3112.         $this->isDemoProduct = $isDemoProduct;
  3114.         return $this;
  3115.     }
  3117.     /**
  3118.      * Product marks
  3119.      *
  3120.      * @return IMark[]
  3121.      */
  3122.     public function getMarks(): array
  3123.     {
  3124.         return [];
  3125.     }
  3126. }