classes/XLite/Model/Product.php line 80

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