classes/XLite/Model/Product.php line 67

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