classes/XLite/Model/Product.php line 65

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.  *      }
  35.  * )
  36.  * @ApiPlatform\ApiResource(
  37.  *     input=ProductInput::class,
  38.  *     output=ProductOutput::class,
  39.  *     itemOperations={
  40.  *         "get"={
  41.  *             "method"="GET",
  42.  *             "path"="/products/{product_id}",
  43.  *             "identifiers"={"product_id"},
  44.  *         },
  45.  *         "put"={
  46.  *             "method"="PUT",
  47.  *             "path"="/products/{product_id}",
  48.  *             "identifiers"={"product_id"},
  49.  *         },
  50.  *         "delete"={
  51.  *             "method"="DELETE",
  52.  *             "path"="/products/{product_id}",
  53.  *             "identifiers"={"product_id"},
  54.  *         }
  55.  *     },
  56.  *     collectionOperations={
  57.  *         "get"={
  58.  *             "method"="GET",
  59.  *             "path"="/products",
  60.  *             "identifiers"={"product_id"},
  61.  *         },
  62.  *         "post"={
  63.  *             "method"="POST",
  64.  *             "path"="/products",
  65.  *             "identifiers"={"product_id"},
  66.  *         }
  67.  *     }
  68.  * )
  69.  * @ApiPlatform\ApiFilter(IntegerDateFilter::class, properties={"updateDate"})
  70.  * @ApiPlatform\ApiFilter(TranslationAwareOrderFilter::class, properties={"name"="ASC","price"="ASC","arrivalDate"="ASC"})
  71.  */
  72. class Product extends \XLite\Model\Base\Catalog implements \XLite\Model\Base\IOrderItem, EntityVersionInterface
  73. {
  74.     use EntityVersionTrait;
  75.     use ExecuteCachedTrait;
  77.     /**
  78.      * Default amounts
  79.      */
  80.     public const AMOUNT_DEFAULT_INV_TRACK = 1000;
  81.     public const AMOUNT_DEFAULT_LOW_LIMIT = 10;
  83.     /**
  84.      * Meta description type
  85.      */
  86.     public const META_DESC_TYPE_AUTO   = 'A';
  87.     public const META_DESC_TYPE_CUSTOM = 'C';
  89.     /**
  90.      * Product unique ID
  91.      *
  92.      * @var integer
  93.      *
  94.      * @ORM\Id
  95.      * @ORM\GeneratedValue (strategy="AUTO")
  96.      * @ORM\Column         (type="integer", options={ "unsigned": true })
  97.      */
  98.     protected $product_id;
  100.     /**
  101.      * Product price
  102.      *
  103.      * @var float
  104.      *
  105.      * @ORM\Column (type="decimal", precision=14, scale=4)
  106.      */
  107.     protected $price = 0.0000;
  109.     /**
  110.      * Product SKU
  111.      *
  112.      * @var string
  113.      *
  114.      * @ORM\Column (type="string", length=32, nullable=true)
  115.      */
  116.     protected $sku;
  118.     /**
  119.      * Is product available or not
  120.      *
  121.      * @var boolean
  122.      *
  123.      * @ORM\Column (type="boolean")
  124.      */
  125.     protected $enabled = true;
  127.     /**
  128.      * Product weight
  129.      *
  130.      * @var float
  131.      *
  132.      * @ORM\Column (type="decimal", precision=14, scale=4)
  133.      */
  134.     protected $weight = 0.0000;
  136.     /**
  137.      * Is product shipped in separate box
  138.      *
  139.      * @var boolean
  140.      *
  141.      * @ORM\Column (type="boolean")
  142.      */
  143.     protected $useSeparateBox = false;
  145.     /**
  146.      * Product box width
  147.      *
  148.      * @var float
  149.      *
  150.      * @ORM\Column (type="decimal", precision=14, scale=4)
  151.      */
  152.     protected $boxWidth = 0.0000;
  154.     /**
  155.      * Product box length
  156.      *
  157.      * @var float
  158.      *
  159.      * @ORM\Column (type="decimal", precision=14, scale=4)
  160.      */
  161.     protected $boxLength = 0.0000;
  163.     /**
  164.      * Product box height
  165.      *
  166.      * @var float
  167.      *
  168.      * @ORM\Column (type="decimal", precision=14, scale=4)
  169.      */
  170.     protected $boxHeight = 0.0000;
  172.     /**
  173.      * How many product items can be placed in a box
  174.      *
  175.      * @var integer
  176.      *
  177.      * @ORM\Column (type="integer")
  178.      */
  179.     protected $itemsPerBox = 1;
  181.     /**
  182.      * Flag: false - product is shippable, true - product is not shippable
  183.      *
  184.      * @var boolean
  185.      *
  186.      * @ORM\Column (type="boolean")
  187.      */
  188.     protected $free_shipping = false;
  190.     /**
  191.      * If false then the product is free from any taxes
  192.      *
  193.      * @var boolean
  194.      *
  195.      * @ORM\Column (type="boolean")
  196.      */
  197.     protected $taxable = true;
  199.     /**
  200.      * Arrival date (UNIX timestamp)
  201.      *
  202.      * @var integer
  203.      *
  204.      * @ORM\Column (type="integer")
  205.      */
  206.     protected $arrivalDate = 0;
  208.     /**
  209.      * Creation date (UNIX timestamp)
  210.      *
  211.      * @var integer
  212.      *
  213.      * @ORM\Column (type="integer")
  214.      */
  215.     protected $date = 0;
  217.     /**
  218.      * Update date (UNIX timestamp)
  219.      *
  220.      * @var integer
  221.      *
  222.      * @ORM\Column (type="integer", options={ "unsigned": true })
  223.      */
  224.     protected $updateDate = 0;
  226.     /**
  227.      * Is product need process or not
  228.      *
  229.      * @var boolean
  230.      *
  231.      * @ORM\Column (type="boolean")
  232.      */
  233.     protected $needProcess = true;
  235.     /**
  236.      * Relation to a CategoryProducts entities
  237.      *
  238.      * @var \Doctrine\ORM\PersistentCollection
  239.      *
  240.      * @ORM\OneToMany (targetEntity="XLite\Model\CategoryProducts", mappedBy="product", cascade={"all"})
  241.      * @ORM\OrderBy   ({"orderbyInProduct" = "ASC"})
  242.      */
  243.     protected $categoryProducts;
  245.     /**
  246.      * Product order items
  247.      *
  248.      * @var \XLite\Model\OrderItem
  249.      *
  250.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderItem", mappedBy="object")
  251.      */
  252.     protected $order_items;
  254.     /**
  255.      * Product images
  256.      *
  257.      * @var \Doctrine\Common\Collections\Collection
  258.      *
  259.      * @ORM\OneToMany (targetEntity="XLite\Model\Image\Product\Image", mappedBy="product", cascade={"all"})
  260.      * @ORM\OrderBy   ({"orderby" = "ASC"})
  261.      */
  262.     protected $images;
  264.     // {{{ Inventory properties
  266.     /**
  267.      * Is inventory tracking enabled or not
  268.      *
  269.      * @var boolean
  270.      *
  271.      * @ORM\Column (type="boolean")
  272.      */
  273.     protected $inventoryEnabled = true;
  275.     /**
  276.      * Amount
  277.      *
  278.      * @var integer
  279.      *
  280.      * @ORM\Column (type="integer", options={ "unsigned": true })
  281.      */
  282.     protected $amount = self::AMOUNT_DEFAULT_INV_TRACK;
  284.     /**
  285.      * Is low limit notification enabled for customer or not
  286.      *
  287.      * @var boolean
  288.      *
  289.      * @ORM\Column (type="boolean")
  290.      */
  291.     protected $lowLimitEnabledCustomer = true;
  293.     /**
  294.      * Is low limit notification enabled for admin or not
  295.      *
  296.      * @var boolean
  297.      *
  298.      * @ORM\Column (type="boolean")
  299.      */
  300.     protected $lowLimitEnabled = false;
  302.     /**
  303.      * Low limit amount
  304.      *
  305.      * @var integer
  306.      *
  307.      * @ORM\Column (type="integer", options={ "unsigned": true })
  308.      */
  309.     protected $lowLimitAmount = self::AMOUNT_DEFAULT_LOW_LIMIT;
  311.     // }}}
  313.     /**
  314.      * Product class (relation)
  315.      *
  316.      * @var \XLite\Model\ProductClass
  317.      *
  318.      * @ORM\ManyToOne  (targetEntity="XLite\Model\ProductClass")
  319.      * @ORM\JoinColumn (name="product_class_id", referencedColumnName="id", onDelete="SET NULL")
  320.      */
  321.     protected $productClass;
  323.     /**
  324.      * Tax class (relation)
  325.      *
  326.      * @var \XLite\Model\TaxClass
  327.      *
  328.      * @ORM\ManyToOne  (targetEntity="XLite\Model\TaxClass")
  329.      * @ORM\JoinColumn (name="tax_class_id", referencedColumnName="id", onDelete="SET NULL")
  330.      */
  331.     protected $taxClass;
  333.     /**
  334.      * Attributes
  335.      *
  336.      * @var \Doctrine\Common\Collections\Collection
  337.      *
  338.      * @ORM\OneToMany (targetEntity="XLite\Model\Attribute", mappedBy="product", cascade={"all"})
  339.      * @ORM\OrderBy   ({"position" = "ASC"})
  340.      */
  341.     protected $attributes;
  343.     /**
  344.      * Attribute value (checkbox)
  345.      *
  346.      * @var \Doctrine\Common\Collections\Collection
  347.      *
  348.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueCheckbox", mappedBy="product", cascade={"all"})
  349.      */
  350.     protected $attributeValueC;
  352.     /**
  353.      * Attribute value (text)
  354.      *
  355.      * @var \Doctrine\Common\Collections\Collection
  356.      *
  357.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueText", mappedBy="product", cascade={"all"})
  358.      */
  359.     protected $attributeValueT;
  361.     /**
  362.      * Attribute value (select)
  363.      *
  364.      * @var \Doctrine\Common\Collections\Collection
  365.      *
  366.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueSelect", mappedBy="product", cascade={"all"})
  367.      */
  368.     protected $attributeValueS;
  370.     /**
  371.      * Attribute value (hidden)
  372.      *
  373.      * @var \Doctrine\Common\Collections\Collection
  374.      *
  375.      * @ORM\OneToMany (targetEntity="XLite\Model\AttributeValue\AttributeValueHidden", mappedBy="product", cascade={"all"})
  376.      */
  377.     protected $attributeValueH;
  379.     /**
  380.      * Show product attributes in a separate tab
  381.      *
  382.      * @var boolean
  383.      *
  384.      * @ORM\Column (type="boolean")
  385.      */
  386.     protected $attrSepTab = true;
  388.     /**
  389.      * How much product is sold (used in Top selling products statistics)
  390.      *
  391.      * @var integer
  392.      */
  393.     protected $sold = 0;
  395.     /**
  396.      * Quick data
  397.      *
  398.      * @var \Doctrine\Common\Collections\Collection
  399.      *
  400.      * @ORM\OneToMany (targetEntity="XLite\Model\QuickData", mappedBy="product", cascade={"all"})
  401.      */
  402.     protected $quickData;
  404.     /**
  405.      * Storage of current attribute values according to the clear price will be calculated
  406.      *
  407.      * @var array
  408.      */
  409.     protected $attrValues = [];
  411.     /**
  412.      * Memberships
  413.      *
  414.      * @var \Doctrine\Common\Collections\ArrayCollection
  415.      *
  416.      * @ORM\ManyToMany (targetEntity="XLite\Model\Membership", inversedBy="products")
  417.      * @ORM\JoinTable (name="product_membership_links",
  418.      *      joinColumns={@ORM\JoinColumn (name="product_id", referencedColumnName="product_id", onDelete="CASCADE")},
  419.      *      inverseJoinColumns={@ORM\JoinColumn (name="membership_id", referencedColumnName="membership_id", onDelete="CASCADE")}
  420.      * )
  421.      */
  422.     protected $memberships;
  424.     /**
  425.      * Clean URLs
  426.      *
  427.      * @var \Doctrine\Common\Collections\Collection
  428.      *
  429.      * @ORM\OneToMany (targetEntity="XLite\Model\CleanURL", mappedBy="product", cascade={"all"})
  430.      * @ORM\OrderBy   ({"id" = "ASC"})
  431.      */
  432.     protected $cleanURLs;
  434.     /**
  435.      * Meta description type
  436.      *
  437.      * @var string
  438.      *
  439.      * @ORM\Column (type="string", length=1)
  440.      */
  441.     protected $metaDescType = 'A';
  443.     /**
  444.      * Sales
  445.      *
  446.      * @var integer
  447.      *
  448.      * @ORM\Column (type="integer", options={ "unsigned": true })
  449.      */
  450.     protected $sales = 0;
  452.     /**
  453.      * Flag to exporting entities
  454.      *
  455.      * @var boolean
  456.      *
  457.      * @ORM\Column (type="boolean")
  458.      */
  459.     protected $xcPendingExport = false;
  461.     /**
  462.      * @var \Doctrine\Common\Collections\Collection
  463.      *
  464.      * @ORM\OneToMany (targetEntity="XLite\Model\ProductTranslation", mappedBy="owner", cascade={"all"})
  465.      */
  466.     protected $translations;
  468.     /**
  469.      * Flag for demo products.
  470.      *
  471.      * @ORM\Column (type="boolean")
  472.      */
  473.     protected bool $isDemoProduct = false;
  476.   /**
  477.      * @ORM\Column (type="integer", options={ "unsigned": true, "default": 0 })
  478.      */
  479.     protected $quantity1 = 0;
  481.     /**
  482.      * Get csiMultiple
  483.      *
  484.      * @return int
  485.      */
  486.     public function getquantity1()
  487.     {
  488.         return (int) $this->quantity1;
  489.     }
  491.     /**
  492.      * Set csiMultiple
  493.      *
  494.      * @param int $csiMultiple
  495.      *
  496.      * @return self
  497.      */
  498.     public function setquantity1($quantity1)
  499.     {
  500.         $this->quantity1 = (int) $quantity1;
  502.         return $this;
  503.     }
  505.     /**
  506.      * Return GlobalTabs
  507.      *
  508.      * @return \XLite\Model\Product\GlobalTab[]
  509.      */
  510.     public function getGlobalTabs()
  511.     {
  512.         return $this->executeCachedRuntime(static function () {
  513.             return \XLite\Core\Database::getRepo('\XLite\Model\Product\GlobalTab')->findAll();
  514.         }, ['getGlobalTabs']);
  515.     }
  517.     /**
  518.      * Clone
  519.      *
  520.      * @return static
  521.      */
  522.     public function cloneEntity()
  523.     {
  524.         /** @var Product $newProduct */
  525.         $newProduct = parent::cloneEntity();
  527.         $this->cloneEntityScalar($newProduct);
  529.         if (!$newProduct->update() || !$newProduct->getProductId()) {
  530.             throw new FatalException('Can not clone product');
  531.         }
  533.         $this->cloneEntityModels($newProduct);
  534.         $this->cloneEntityCategories($newProduct);
  535.         $this->cloneEntityAttributes($newProduct);
  536.         $this->cloneEntityImages($newProduct);
  537.         $this->cloneEntityMemberships($newProduct);
  539.         $newProduct->update();
  541.         foreach ($newProduct->getCleanURLs() as $url) {
  542.             $newProduct->getCleanURLs()->removeElement($url);
  543.             \XLite\Core\Database::getEM()->remove($url);
  544.         }
  546.         $newProduct->setSales(0);
  548.         return $newProduct;
  549.     }
  551.     /**
  552.      * Clone entity (scalar fields)
  553.      *
  554.      * @param Product $newProduct New product
  555.      *
  556.      * @return void
  557.      */
  558.     protected function cloneEntityScalar(Product $newProduct)
  559.     {
  560.         $newProduct->setSku(\XLite\Core\Database::getRepo('XLite\Model\Product')->assembleUniqueSKU($this->getSku()));
  561.         $newProduct->setName($this->getCloneName($this->getName()));
  562.     }
  564.     /**
  565.      * Clone entity (model fields)
  566.      *
  567.      * @param Product $newProduct New product
  568.      *
  569.      * @return void
  570.      */
  571.     protected function cloneEntityModels(Product $newProduct)
  572.     {
  573.         $newProduct->setTaxClass($this->getTaxClass());
  574.         $newProduct->setProductClass($this->getProductClass());
  575.     }
  577.     /**
  578.      * Clone entity (categories)
  579.      *
  580.      * @param Product $newProduct New product
  581.      *
  582.      * @return void
  583.      */
  584.     protected function cloneEntityCategories(Product $newProduct)
  585.     {
  586.         foreach ($this->getCategories() as $category) {
  587.             $link = new \XLite\Model\CategoryProducts();
  588.             $link->setProduct($newProduct);
  589.             $link->setCategory($category);
  590.             $newProduct->addCategoryProducts($link);
  591.             \XLite\Core\Database::getEM()->persist($link);
  592.         }
  593.     }
  595.     /**
  596.      * Clone entity (attributes)
  597.      *
  598.      * @param Product $newProduct New product
  599.      *
  600.      * @return void
  601.      */
  602.     protected function cloneEntityAttributes(Product $newProduct)
  603.     {
  604.         foreach (\XLite\Model\Attribute::getTypes() as $type => $name) {
  605.             $methodGet = 'getAttributeValue' . $type;
  606.             $methodAdd = 'addAttributeValue' . $type;
  607.             $groups    = [];
  608.             foreach ($this->$methodGet() as $value) {
  609.                 if (!$value->getAttribute()->getProduct()) {
  610.                     $newValue = $value->cloneEntity();
  611.                     $newValue->setProduct($newProduct);
  612.                     $newProduct->$methodAdd($newValue);
  613.                     \XLite\Core\Database::getEM()->persist($newValue);
  615.                     $attribute = $value->getAttribute();
  616.                     $property  = $attribute->getProperty($value->getProduct());
  617.                     if ($property && $value instanceof \XLite\Model\AttributeValue\Multiple) {
  618.                         $groups[$attribute->getId()] = [
  619.                             'attr'     => $attribute,
  620.                             'property' => $property,
  621.                         ];
  622.                     }
  623.                 }
  624.             }
  626.             foreach ($groups as $group) {
  627.                 $newProperty = $group['property']->cloneEntity();
  628.                 $newProperty->setProduct($newProduct);
  629.                 $newProperty->setAttribute($group['attr']);
  630.                 \XLite\Core\Database::getEM()->persist($newProperty);
  631.             }
  632.         }
  634.         foreach ($this->getAttributes() as $attribute) {
  635.             $class        = $attribute->getAttributeValueClass($attribute->getType());
  636.             $repo         = \XLite\Core\Database::getRepo($class);
  637.             $methodAdd    = 'addAttributeValue' . $attribute->getType();
  638.             $newAttribute = $attribute->cloneEntity();
  639.             $newAttribute->setProduct($newProduct);
  640.             $newProduct->addAttributes($newAttribute);
  641.             \XLite\Core\Database::getEM()->persist($newAttribute);
  642.             foreach ($repo->findBy(['attribute' => $attribute, 'product' => $this]) as $value) {
  643.                 $newValue = $value->cloneEntity();
  644.                 $newValue->setProduct($newProduct);
  645.                 $newValue->setAttribute($newAttribute);
  646.                 $newProduct->$methodAdd($newValue);
  647.                 \XLite\Core\Database::getEM()->persist($newValue);
  648.             }
  649.         }
  650.     }
  652.     /**
  653.      * Clone entity (images)
  654.      *
  655.      * @param Product $newProduct New product
  656.      *
  657.      * @return void
  658.      */
  659.     protected function cloneEntityImages(Product $newProduct)
  660.     {
  661.         foreach ($this->getImages() as $image) {
  662.             $newImage = $image->cloneEntity();
  663.             $newImage->setProduct($newProduct);
  664.             $newProduct->addImages($newImage);
  665.         }
  666.     }
  668.     /**
  669.      * Clone entity (memberships)
  670.      *
  671.      * @param Product $newProduct New product
  672.      *
  673.      * @return void
  674.      */
  675.     protected function cloneEntityMemberships(Product $newProduct)
  676.     {
  677.         foreach ($this->getMemberships() as $membership) {
  678.             $newProduct->addMemberships($membership);
  679.         }
  680.     }
  682.     /**
  683.      * Constructor
  684.      *
  685.      * @param array $data Entity properties OPTIONAL
  686.      */
  687.     public function __construct(array $data = [])
  688.     {
  689.         $this->categoryProducts = new \Doctrine\Common\Collections\ArrayCollection();
  690.         $this->images           = new \Doctrine\Common\Collections\ArrayCollection();
  691.         $this->order_items      = new \Doctrine\Common\Collections\ArrayCollection();
  692.         $this->memberships      = new \Doctrine\Common\Collections\ArrayCollection();
  693.         $this->attributeValueC  = new \Doctrine\Common\Collections\ArrayCollection();
  694.         $this->attributeValueS  = new \Doctrine\Common\Collections\ArrayCollection();
  695.         $this->attributeValueT  = new \Doctrine\Common\Collections\ArrayCollection();
  696.         $this->attributes       = new \Doctrine\Common\Collections\ArrayCollection();
  697.         $this->quickData        = new \Doctrine\Common\Collections\ArrayCollection();
  698.         $this->free_shipping    = !\XLite\Core\Config::getInstance()->General->requires_shipping_default;
  700.         parent::__construct($data);
  701.     }
  703.     /**
  704.      * Get object unique id
  705.      *
  706.      * @return integer
  707.      */
  708.     public function getId()
  709.     {
  710.         return $this->getProductId();
  711.     }
  713.     /**
  714.      * Get weight
  715.      *
  716.      * @return float
  717.      */
  718.     public function getWeight()
  719.     {
  720.         return $this->weight;
  721.     }
  723.     /**
  724.      * Get price: modules should never overwrite this method
  725.      *
  726.      * @return float
  727.      */
  728.     public function getPrice()
  729.     {
  730.         return $this->price;
  731.     }
  733.     /**
  734.      * Get clear price: this price can be overwritten by modules
  735.      *
  736.      * @return float
  737.      */
  738.     public function getClearPrice()
  739.     {
  740.         return $this->getPrice();
  741.     }
  743.     /**
  744.      * Get net Price
  745.      *
  746.      * @return float
  747.      */
  748.     public function getNetPrice()
  749.     {
  750.         return \XLite\Logic\Price::getInstance()->apply($this, 'getClearPrice', ['taxable'], 'net');
  751.     }
  753.     /**
  754.      * Get display Price
  755.      *
  756.      * @return float
  757.      */
  758.     public function getDisplayPrice()
  759.     {
  760.         return \XLite\Logic\Price::getInstance()->apply($this, 'getNetPrice', ['taxable'], 'display');
  761.     }
  763.     /**
  764.      * Get quick data price
  765.      *
  766.      * @return float
  767.      */
  768.     public function getQuickDataPrice()
  769.     {
  770.         $price = $this->getClearPrice();
  772.         foreach ($this->prepareAttributeValues() as $av) {
  773.             if (is_object($av)) {
  774.                 $price += $av->getAbsoluteValue('price');
  775.             }
  776.         }
  778.         return $price;
  779.     }
  781.     /**
  782.      * Get clear weight
  783.      *
  784.      * @return float
  785.      */
  786.     public function getClearWeight()
  787.     {
  788.         return $this->getWeight();
  789.     }
  791.     /**
  792.      * Get name
  793.      *
  794.      * @return string
  795.      */
  796.     public function getName()
  797.     {
  798.         return $this->getSoftTranslation()->getName();
  799.     }
  801.     /**
  802.      * Get SKU
  803.      *
  804.      * @return string
  805.      */
  806.     public function getSku()
  807.     {
  808.         return $this->sku !== null ? (string) $this->sku : null;
  809.     }
  811.     /**
  812.      * Get quantity of the product
  813.      *
  814.      * @return integer
  815.      */
  816.     public function getQty()
  817.     {
  818.         return $this->getPublicAmount();
  819.     }
  821.     /**
  822.      * Get image
  823.      *
  824.      * @return \XLite\Model\Image\Product\Image
  825.      */
  826.     public function getImage()
  827.     {
  828.         return $this->getImages()->get(0);
  829.     }
  831.     /**
  832.      * Get public images
  833.      *
  834.      * @return array
  835.      */
  836.     public function getPublicImages()
  837.     {
  838.         return $this->getImages()->toArray();
  839.     }
  841.     /**
  842.      * Get free shipping flag
  843.      *
  844.      * @return boolean
  845.      */
  846.     public function getFreeShipping()
  847.     {
  848.         return $this->free_shipping;
  849.     }
  851.     /**
  852.      * Get shippable flag
  853.      *
  854.      * @return boolean
  855.      */
  856.     public function getShippable()
  857.     {
  858.         return !$this->getFreeShipping();
  859.     }
  861.     /**
  862.      * Set shippable flag
  863.      *
  864.      * @param boolean $value Value
  865.      *
  866.      * @return void
  867.      */
  868.     public function setShippable($value)
  869.     {
  870.         $this->setFreeShipping(!$value);
  871.     }
  873.     /**
  874.      * Return true if product can be purchased
  875.      *
  876.      * @return boolean
  877.      */
  878.     public function isAvailable()
  879.     {
  880.         return \XLite::isAdminZone() || $this->isPublicAvailable();
  881.     }
  883.     /**
  884.      * Return true if product can be purchased in customer interface
  885.      *
  886.      * @return boolean
  887.      */
  888.     public function isPublicAvailable()
  889.     {
  890.         return $this->isVisible()
  891.             && $this->availableInDate()
  892.             && !$this->isOutOfStock();
  893.     }
  895.     /**
  896.      * Check product visibility
  897.      *
  898.      * @return boolean
  899.      */
  900.     public function isVisible()
  901.     {
  902.         return $this->getEnabled()
  903.             && $this->hasAvailableMembership();
  904.     }
  906.     /**
  907.      * Get membership Ids
  908.      *
  909.      * @return array
  910.      */
  911.     public function getMembershipIds()
  912.     {
  913.         $result = [];
  915.         foreach ($this->getMemberships() as $membership) {
  916.             $result[] = $membership->getMembershipId();
  917.         }
  919.         return $result;
  920.     }
  922.     /**
  923.      * Flag if the category and active profile have the same memberships. (when category is displayed or hidden)
  924.      *
  925.      * @return boolean
  926.      */
  927.     public function hasAvailableMembership()
  928.     {
  929.         return $this->getMemberships()->count() === 0
  930.             || in_array(\XLite\Core\Auth::getInstance()->getMembershipId(), $this->getMembershipIds());
  931.     }
  933.     /**
  934.      * Flag if the product is available according date/time
  935.      *
  936.      * @return boolean
  937.      */
  938.     public function availableInDate()
  939.     {
  940.         return !$this->getArrivalDate()
  941.             || \XLite\Core\Converter::getDayEnd(static::getUserTime()) > $this->getArrivalDate();
  942.     }
  944.     /**
  945.      * Check if product has image or not
  946.      *
  947.      * @return boolean
  948.      */
  949.     public function hasImage()
  950.     {
  951.         return $this->getImage() !== null && $this->getImage()->isPersistent();
  952.     }
  954.     /**
  955.      * Return image URL
  956.      *
  957.      * @return string|void
  958.      */
  959.     public function getImageURL()
  960.     {
  961.         return $this->getImage() ? $this->getImage()->getURL() : null;
  962.     }
  964.     /**
  965.      * Return random product category
  966.      *
  967.      * @param integer|null $categoryId Category ID OPTIONAL
  968.      *
  969.      * @return \XLite\Model\Category
  970.      */
  971.     public function getCategory($categoryId = null)
  972.     {
  973.         $result = $this->getLink($categoryId)->getCategory();
  975.         if (empty($result)) {
  976.             $result = new \XLite\Model\Category();
  977.         }
  979.         return $result;
  980.     }
  982.     /**
  983.      * Return random product category ID
  984.      *
  985.      * @param integer|null $categoryId Category ID OPTIONAL
  986.      *
  987.      * @return integer
  988.      */
  989.     public function getCategoryId($categoryId = null)
  990.     {
  991.         return $this->getCategory($categoryId)->getCategoryId();
  992.     }
  994.     /**
  995.      * Return list of product categories
  996.      *
  997.      * @return array
  998.      */
  999.     public function getCategories()
  1000.     {
  1001.         $result = [];
  1003.         foreach ($this->getCategoryProducts() as $cp) {
  1004.             $result[] = $cp->getCategory();
  1005.         }
  1007.         return $result;
  1008.     }
  1010.     // {{{ Inventory methods
  1012.     /**
  1013.      * Setter
  1014.      *
  1015.      * @param int $value Value to setcookie(name)
  1016.      *
  1017.      * @return void
  1018.      */
  1019.     public function setAmount($value)
  1020.     {
  1021.         $this->amount = $this->correctAmount($value);
  1022.     }
  1024.     /**
  1025.      * Setter
  1026.      *
  1027.      * @param integer $amount Amount to set
  1028.      *
  1029.      * @return void
  1030.      */
  1031.     public function setLowLimitAmount($amount)
  1032.     {
  1033.         $this->lowLimitAmount = $this->correctAmount($amount);
  1034.     }
  1036.     /**
  1037.      * Increase / decrease product inventory amount
  1038.      *
  1039.      * @param integer $delta Amount delta
  1040.      *
  1041.      * @return void
  1042.      */
  1043.     public function changeAmount($delta)
  1044.     {
  1046.         if ($this->getInventoryEnabled()) {
  1047.             if($delta<0)
  1048.             {
  1049.                 if($this->getquantity1()+$delta>-1)
  1050.                 {
  1051.                     $this->setquantity1($this->getquantity1() + $delta);
  1052.                 }
  1053.                 else
  1054.                 {
  1055.                    
  1056.                    $rest=$this->getquantity1()+$delta;
  1057.                     $this->setquantity1(0);
  1058.                        $this->setAmount($this->getPublicAmount()+ $rest);
  1059.                 }
  1060.             }
  1061.             else
  1062.             {
  1063.                 $this->setAmount($this->getPublicAmount()-$this->getquantity1() + $delta);
  1064.             }
  1065.             
  1066.         }
  1067.     }
  1069.     /**
  1070.      * Get public amount
  1071.      *
  1072.      * @return integer
  1073.      */
  1074.     public function getPublicAmount()
  1075.     {
  1076.         return $this->getAmount()+$this->getquantity1();
  1077.     }
  1079.     /**
  1080.      * Get low available amount
  1081.      *
  1082.      * @return integer
  1083.      */
  1084.     public function getLowAvailableAmount()
  1085.     {
  1086.         return $this->getInventoryEnabled()
  1087.             ? min($this->getLowDefaultAmount(), $this->getAvailableAmount())
  1088.             : $this->getLowDefaultAmount();
  1089.     }
  1091.     /**
  1092.      * Check if product amount is less than its low limit
  1093.      *
  1094.      * @return boolean
  1095.      */
  1096.     public function isLowLimitReached()
  1097.     {
  1098.         return $this->getInventoryEnabled()
  1099.             && $this->getLowLimitEnabled()
  1100.             && $this->getPublicAmount() <= $this->getLowLimitAmount();
  1101.     }
  1103.     /**
  1104.      * List of controllers which should not send notifications
  1105.      *
  1106.      * @return array
  1107.      */
  1108.     protected function getForbiddenControllers()
  1109.     {
  1110.         return [
  1111.             '\XLite\Controller\Admin\EventTask',
  1112.             '\XLite\Controller\Admin\ProductList',
  1113.             '\XLite\Controller\Admin\Product',
  1114.         ];
  1115.     }
  1117.     /**
  1118.      * Check if notifications should be sended in current situation
  1119.      *
  1120.      * @return boolean
  1121.      */
  1122.     public function isShouldSend()
  1123.     {
  1124.         $result = false;
  1126.         if (!defined('LC_CACHE_BUILDING')) {
  1127.             $currentController     = \XLite::getInstance()->getController();
  1128.             $isControllerForbidden = array_reduce(
  1129.                 $this->getForbiddenControllers(),
  1130.                 static function ($carry, $controllerName) use ($currentController) {
  1131.                     return $carry ?: ($currentController instanceof $controllerName);
  1132.                 },
  1133.                 false
  1134.             );
  1136.             $result = \XLite\Core\Request::getInstance()->event !== 'import'
  1137.                 && !$isControllerForbidden;
  1138.         }
  1140.         return $result;
  1141.     }
  1143.     /**
  1144.      * Check and (if needed) correct amount value
  1145.      *
  1146.      * @param integer $amount Value to check
  1147.      *
  1148.      * @return integer
  1149.      */
  1150.     protected function correctAmount($amount)
  1151.     {
  1152.         return Converter::toUnsigned32BitInt($amount);
  1153.     }
  1155.     /**
  1156.      * Get a low default amount
  1157.      *
  1158.      * @return integer
  1159.      */
  1160.     protected function getLowDefaultAmount()
  1161.     {
  1162.         return 1;
  1163.     }
  1165.     /**
  1166.      * Default qty value to show to customers
  1167.      *
  1168.      * @return integer
  1169.      */
  1170.     public function getDefaultAmount()
  1171.     {
  1172.         return static::AMOUNT_DEFAULT_INV_TRACK;
  1173.     }
  1175.     /**
  1176.      * Get ProductStockAvailabilityPolicy associated with this product
  1177.      *
  1178.      * @return ProductStockAvailabilityPolicy
  1179.      */
  1180.     public function getStockAvailabilityPolicy()
  1181.     {
  1182.         return new ProductStockAvailabilityPolicy($this);
  1183.     }
  1185.     /**
  1186.      * Return product amount available to add to cart
  1187.      *
  1188.      * @return integer
  1189.      */
  1190.     public function getAvailableAmount()
  1191.     {
  1192.         return $this->getStockAvailabilityPolicy()->getAvailableAmount(Cart::getInstance());
  1193.     }
  1195.     /**
  1196.      * Alias: is product in stock or not
  1197.      *
  1198.      * @return boolean
  1199.      */
  1200.     public function isOutOfStock()
  1201.     {
  1202.         return $this->getAmount() <= 0 && $this->getInventoryEnabled();
  1203.     }
  1205.     /**
  1206.      * Alias: is all product items in cart
  1207.      *
  1208.      * @return boolean
  1209.      */
  1210.     public function isAllStockInCart()
  1211.     {
  1212.         return $this->getStockAvailabilityPolicy()->isAllStockInCart(Cart::getInstance());
  1213.     }
  1215.     /**
  1216.      * How many product items added to cart
  1217.      *
  1218.      * @return boolean
  1219.      */
  1220.     public function getItemsInCart()
  1221.     {
  1222.         return $this->getStockAvailabilityPolicy()->getInCartAmount(Cart::getInstance());
  1223.     }
  1225.     /**
  1226.      * How many product items added to cart
  1227.      *
  1228.      * @return boolean
  1229.      */
  1230.     public function getItemsInCartMessage()
  1231.     {
  1232.         $count = $this->getStockAvailabilityPolicy()->getInCartAmount(Cart::getInstance());
  1234.         return \XLite\Core\Translation::getInstance()->translate(
  1235.             'Items in your cart: X',
  1236.             ['count' => $count]
  1237.         );
  1238.     }
  1240.     /**
  1241.      * Check if the product is out-of-stock
  1242.      *
  1243.      * @return boolean
  1244.      */
  1245.     public function isShowStockWarning()
  1246.     {
  1247.         return $this->getInventoryEnabled()
  1248.             && $this->getLowLimitEnabledCustomer()
  1249.             && $this->getPublicAmount() <= $this->getLowLimitAmount()
  1250.             && !$this->isOutOfStock();
  1251.     }
  1253.     /**
  1254.      * Check if the product is out-of-stock
  1255.      *
  1256.      * @return boolean
  1257.      */
  1258.     public function isShowOutOfStockWarning()
  1259.     {
  1260.         return $this->getInventoryEnabled()
  1261.             && $this->isOutOfStock();
  1262.     }
  1264.     /**
  1265.      * Send notification to admin about product low limit
  1266.      *
  1267.      * @return void
  1268.      */
  1269.     public function sendLowLimitNotification()
  1270.     {
  1271.         \XLite\Core\Mailer::sendLowLimitWarningAdmin($this->prepareDataForNotification());
  1272.     }
  1274.     /**
  1275.      * Prepare data for 'low limit warning' email notifications
  1276.      *
  1277.      * @return array
  1278.      */
  1279.     public function prepareDataForNotification()
  1280.     {
  1281.         $data = [];
  1283.         $data['product'] = $this;
  1284.         $data['name']    = $this->getName();
  1285.         $data['sku']     = $this->getSKU();
  1286.         $data['amount']  = $this->getAmount();
  1288.         $params           = [
  1289.             'product_id' => $this->getProductId(),
  1290.             'page'       => 'inventory',
  1291.         ];
  1292.         $data['adminURL'] = \XLite\Core\Converter::buildFullURL('product', '', $params, \XLite::getAdminScript(), false);
  1294.         return $data;
  1295.     }
  1297.     // }}}
  1299.     /**
  1300.      * Set sku and trim it to max length
  1301.      *
  1302.      * @param string $sku
  1303.      *
  1304.      * @return void
  1305.      */
  1306.     public function setSku($sku)
  1307.     {
  1308.         $this->sku = substr(
  1309.             $sku,
  1310.             0,
  1311.             \XLite\Core\Database::getRepo('XLite\Model\Product')->getFieldInfo('sku', 'length')
  1312.         );
  1313.     }
  1315.     /**
  1316.      * Get product Url
  1317.      *
  1318.      * @return string
  1319.      */
  1320.     public function getURL()
  1321.     {
  1322.         return $this->getProductId()
  1323.             ? \XLite\Core\Converter::makeURLValid(
  1324.                 \XLite\Core\Converter::buildURL('product', '', ['product_id' => $this->getProductId()])
  1325.             )
  1326.             : null;
  1327.     }
  1329.     /**
  1330.      * Get front URL
  1331.      *
  1332.      * @return string
  1333.      */
  1334.     public function getFrontURL($withAttributes = false, $buildCuInAdminZone = false)
  1335.     {
  1336.         return $this->getProductId()
  1337.             ? \XLite\Core\Converter::makeURLValid(
  1338.                 \XLite::getInstance()->getShopURL(
  1339.                     \XLite\Core\Converter::buildURL(
  1340.                         'product',
  1341.                         '',
  1342.                         $this->getParamsForFrontURL($withAttributes),
  1343.                         \XLite::getCustomerScript(),
  1344.                         $buildCuInAdminZone
  1345.                     )
  1346.                 )
  1347.             )
  1348.             : null;
  1349.     }
  1351.     /**
  1352.      * @return array
  1353.      */
  1354.     protected function getParamsForFrontURL($withAttributes = false)
  1355.     {
  1356.         $result = [
  1357.             'product_id' => $this->getProductId(),
  1358.         ];
  1360.         if ($withAttributes) {
  1361.             $result['attribute_values'] = $this->getAttributeValuesParams();
  1362.         }
  1364.         return $result;
  1365.     }
  1367.     /**
  1368.      * @return string
  1369.      */
  1370.     protected function getAttributeValuesParams()
  1371.     {
  1372.         $validAttributes = array_filter(
  1373.             $this->getAttrValues(),
  1374.             static function ($attr) {
  1375.                 return $attr && $attr->getAttribute();
  1376.             }
  1377.         );
  1379.         $paramsStrings = array_map(
  1380.             static function ($attr) {
  1381.                 return $attr->getAttribute()->getId() . '_' . $attr->getId();
  1382.             },
  1383.             $validAttributes
  1384.         );
  1386.         return trim(join(',', $paramsStrings), ',');
  1387.     }
  1389.     /**
  1390.      * Minimal available amount
  1391.      *
  1392.      * @return integer
  1393.      */
  1394.     public function getMinPurchaseLimit()
  1395.     {
  1396.         return 1;
  1397.     }
  1399.     /**
  1400.      * Maximal available amount
  1401.      *
  1402.      * @return integer
  1403.      */
  1404.     public function getMaxPurchaseLimit()
  1405.     {
  1406.         return (int) \XLite\Core\Config::getInstance()->General->default_purchase_limit;
  1407.     }
  1409.     /**
  1410.      * Return product position in category
  1411.      *
  1412.      * @param integer|null $categoryId Category ID OPTIONAL
  1413.      *
  1414.      * @return integer|void
  1415.      */
  1416.     public function getOrderBy($categoryId = null)
  1417.     {
  1418.         $link = $this->getLink($categoryId);
  1420.         return $link ? $link->getOrderBy() : null;
  1421.     }
  1423.     /**
  1424.      * Count product images
  1425.      *
  1426.      * @return integer
  1427.      */
  1428.     public function countImages()
  1429.     {
  1430.         return count($this->getPublicImages());
  1431.     }
  1433.     /**
  1434.      * Try to fetch product description
  1435.      *
  1436.      * @return string
  1437.      */
  1438.     public function getCommonDescription()
  1439.     {
  1440.         return $this->getBriefDescription() ?: $this->getDescription();
  1441.     }
  1443.     /**
  1444.      * Get processed product brief description
  1445.      *
  1446.      * @return string
  1447.      */
  1448.     public function getProcessedBriefDescription()
  1449.     {
  1450.         $value = $this->getBriefDescription();
  1452.         return $value
  1453.             ? static::getPreprocessedValue($value)
  1454.             : $value;
  1455.     }
  1457.     /**
  1458.      * Get processed product description
  1459.      *
  1460.      * @return string
  1461.      */
  1462.     public function getProcessedDescription()
  1463.     {
  1464.         $value = $this->getDescription();
  1466.         return $value
  1467.             ? static::getPreprocessedValue($value)
  1468.             : $value;
  1469.     }
  1471.     /**
  1472.      * Get taxable basis
  1473.      *
  1474.      * @return float
  1475.      */
  1476.     public function getTaxableBasis()
  1477.     {
  1478.         return $this->getNetPrice();
  1479.     }
  1482.     /**
  1483.      * Check if product inventory changed
  1484.      *
  1485.      * @return boolean
  1486.      */
  1487.     public function isInventoryChanged()
  1488.     {
  1489.         $changeset = \XLite\Core\Database::getEM()
  1490.             ->getUnitOfWork()
  1491.             ->getEntityChangeSet($this);
  1493.         return isset($changeset['amount']);
  1494.     }
  1496.     /**
  1497.      * Set product class
  1498.      *
  1499.      * @param ProductClass|null $productClass     Product class OPTIONAL
  1500.      * @param boolean           $preprocessChange Flag if use preprocessChangeProductClass() OPTIONAL
  1501.      *
  1502.      * @return Product
  1503.      */
  1504.     public function setProductClass(\XLite\Model\ProductClass $productClass = null, $preprocessChange = true)
  1505.     {
  1506.         if (
  1507.             $preprocessChange
  1508.             && $this->productClass
  1509.             && (
  1510.                 !$productClass
  1511.                 || $productClass->getId() !== $this->productClass->getId()
  1512.             )
  1513.         ) {
  1514.             $this->preprocessChangeProductClass();
  1515.         }
  1517.         $this->productClass = $productClass;
  1519.         return $this;
  1520.     }
  1522.     /**
  1523.      * Get attr values
  1524.      *
  1525.      * @return array
  1526.      */
  1527.     public function getAttrValues()
  1528.     {
  1529.         return $this->attrValues;
  1530.     }
  1532.     /**
  1533.      * Set attr values
  1534.      *
  1535.      * @param array $value Value
  1536.      *
  1537.      * @return void
  1538.      */
  1539.     public function setAttrValues($value)
  1540.     {
  1541.         $this->attrValues = $value;
  1542.     }
  1544.     /**
  1545.      * Sort editable attributes
  1546.      *
  1547.      * @param array $a Attribute A
  1548.      * @param array $b Attribute B
  1549.      *
  1550.      * @return int
  1551.      */
  1552.     protected function sortEditableAttributes($a, $b)
  1553.     {
  1554.         return $a['position'] > $b['position'] ? 1 : -1;
  1555.     }
  1557.     /**
  1558.      * Get editable attributes
  1559.      *
  1560.      * @return list<\XLite\Model\Attribute>
  1561.      */
  1562.     public function getEditableAttributes()
  1563.     {
  1564.         return $this->executeCachedRuntime(function () {
  1565.             return $this->defineEditableAttributes();
  1566.         }, ['getEditableAttributes', $this->getProductId()]);
  1567.     }
  1569.     /**
  1570.      * @return array
  1571.      */
  1572.     protected function defineEditableAttributes()
  1573.     {
  1574.         $result = [];
  1576.         foreach ((array) \XLite\Model\Attribute::getTypes() as $type => $name) {
  1577.             $class = \XLite\Model\Attribute::getAttributeValueClass($type);
  1578.             if (is_subclass_of($class, 'XLite\Model\AttributeValue\Multiple')) {
  1579.                 $result[] = \XLite\Core\Database::getRepo($class)->findMultipleAttributes($this);
  1580.             } elseif ($class === '\XLite\Model\AttributeValue\AttributeValueText') {
  1581.                 $result[] = \XLite\Core\Database::getRepo($class)->findEditableAttributes($this);
  1582.             }
  1583.         }
  1585.         $result = (array) call_user_func_array('array_merge', $result);
  1586.         usort($result, [$this, 'sortEditableAttributes']);
  1588.         if ($result) {
  1589.             foreach ($result as $k => $v) {
  1590.                 $result[$k] = $v[0];
  1591.             }
  1592.         }
  1594.         return $result;
  1595.     }
  1597.     /**
  1598.      * Sort visible attributes
  1599.      *
  1600.      * @param \XLite\Model\Attribute $a Attribute A
  1601.      * @param \XLite\Model\Attribute $b Attribute B
  1602.      *
  1603.      * @return int
  1604.      */
  1605.     protected function sortVisibleAttributes($a, $b)
  1606.     {
  1607.         return $a->getPosition($this) > $b->getPosition($this) ? 1 : -1;
  1608.     }
  1610.     /**
  1611.      * Get all visible attributes with values
  1612.      *
  1613.      * @return list<\XLite\Model\Attribute>
  1614.      */
  1615.     public function getVisibleAttributes()
  1616.     {
  1617.         return $this->executeCachedRuntime(function () {
  1618.             return $this->defineVisibleAttributes();
  1619.         }, ['getVisibleAttributes', $this->getProductId()]);
  1620.     }
  1622.     /**
  1623.      * @return array
  1624.      */
  1625.     protected function defineVisibleAttributes()
  1626.     {
  1627.         $result = [];
  1629.         foreach ((array) \XLite\Model\Attribute::getTypes() as $type => $name) {
  1630.             if ($type === \XLite\Model\Attribute::TYPE_HIDDEN) {
  1631.                 continue;
  1632.             }
  1634.             $result = array_merge(
  1635.                 $result,
  1636.                 \XLite\Core\Database::getRepo('XLite\Model\Attribute')
  1637.                     ->getAttributesWithValues($this, $type)
  1638.             );
  1639.         }
  1641.         usort($result, [$this, 'sortVisibleAttributes']);
  1643.         return $result;
  1644.     }
  1646.     /**
  1647.      * Check - product has visible attrbiutes or not
  1648.      *
  1649.      * @return boolean
  1650.      */
  1651.     public function hasVisibleAttributes()
  1652.     {
  1653.         return 0 < count($this->getVisibleAttributes());
  1654.     }
  1656.     /**
  1657.      * Get editable attributes ids
  1658.      *
  1659.      * @return array
  1660.      */
  1661.     public function getEditableAttributesIds()
  1662.     {
  1663.         $result = [];
  1665.         foreach ($this->getEditableAttributes() as $a) {
  1666.             $result[] = $a->getId();
  1667.         }
  1668.         sort($result);
  1670.         return $result;
  1671.     }
  1673.     /**
  1674.      * Check - product has editable attrbiutes or not
  1675.      *
  1676.      * @return boolean
  1677.      */
  1678.     public function hasEditableAttributes()
  1679.     {
  1680.         return 0 < count($this->getEditableAttributes());
  1681.     }
  1683.     /**
  1684.      * Get multiple attributes
  1685.      *
  1686.      * @return array
  1687.      */
  1688.     public function getMultipleAttributes()
  1689.     {
  1690.         $result = [];
  1692.         foreach (\XLite\Model\Attribute::getTypes() as $type => $name) {
  1693.             $class = \XLite\Model\Attribute::getAttributeValueClass($type);
  1694.             if (is_subclass_of($class, 'XLite\Model\AttributeValue\Multiple')) {
  1695.                 $result = array_merge(
  1696.                     $result,
  1697.                     \XLite\Core\Database::getRepo($class)->findMultipleAttributes($this)
  1698.                 );
  1699.             }
  1700.         }
  1702.         if ($result) {
  1703.             foreach ($result as $k => $v) {
  1704.                 $result[$k] = $v[0];
  1705.             }
  1706.         }
  1708.         return $result;
  1709.     }
  1711.     /**
  1712.      * Get multiple attributes ids
  1713.      *
  1714.      * @return array
  1715.      */
  1716.     public function getMultipleAttributesIds()
  1717.     {
  1718.         $result = [];
  1720.         foreach ($this->getMultipleAttributes() as $a) {
  1721.             $result[] = $a->getId();
  1722.         }
  1723.         sort($result);
  1725.         return $result;
  1726.     }
  1728.     /**
  1729.      * Check - product has multiple attributes or not
  1730.      *
  1731.      * @return boolean
  1732.      */
  1733.     public function hasMultipleAttributes()
  1734.     {
  1735.         return 0 < count($this->getMultipleAttributes());
  1736.     }
  1738.     /**
  1739.      * Update quick data
  1740.      *
  1741.      * @return void
  1742.      */
  1743.     public function updateQuickData()
  1744.     {
  1745.         if ($this->isPersistent()) {
  1746.             \XLite\Core\QuickData::getInstance()->updateProductData($this);
  1747.         }
  1748.     }
  1750.     /**
  1751.      * @return boolean
  1752.      */
  1753.     protected function showPlaceholderOption()
  1754.     {
  1755.         if (\XLite::isAdminZone()) {
  1756.             return false;
  1757.         } elseif (\XLite\Core\Config::getInstance()->General->force_choose_product_options === 'quicklook') {
  1758.             return \XLite::getController()->getTarget() !== 'product';
  1759.         } elseif (\XLite\Core\Config::getInstance()->General->force_choose_product_options === 'product_page') {
  1760.             return true;
  1761.         }
  1763.         return false;
  1764.     }
  1766.     /**
  1767.      * Prepare attribute values
  1768.      *
  1769.      * @param array $ids Request-based selected attribute values OPTIONAL
  1770.      *
  1771.      * @return array
  1772.      */
  1773.     public function prepareAttributeValues($ids = [])
  1774.     {
  1775.         return $this->executeCachedRuntime(function () use ($ids) {
  1776.             $attributeValues = [];
  1777.             foreach ($this->getEditableAttributes() as $a) {
  1778.                 if ($a->getType() === \XLite\Model\Attribute::TYPE_TEXT) {
  1779.                     $value     = $ids[$a->getId()] ?? $a->getAttributeValue($this)->getValue();
  1780.                     $attrValue = $a->getAttributeValue($this);
  1782.                     $attributeValues[$a->getId()] = [
  1783.                         'attributeValue' => $attrValue,
  1784.                         'value'          => $value,
  1785.                     ];
  1786.                 } elseif ($a->getType() === \XLite\Model\Attribute::TYPE_CHECKBOX) {
  1787.                     $found = null;
  1789.                     if (isset($ids[$a->getId()])) {
  1790.                         foreach ($a->getAttributeValue($this) as $av) {
  1791.                             if ($av->getId() === (int) $ids[$a->getId()]) {
  1792.                                 $found = $av;
  1793.                                 break;
  1794.                             }
  1795.                         }
  1796.                     }
  1798.                     $value = $found ?: $a->getDefaultAttributeValue($this);
  1799.                     $attributeValues[$a->getId()] = $value;
  1800.                 } else {
  1801.                     if (!$this->showPlaceholderOption()) {
  1802.                         $attributeValues[$a->getId()] = $a->getDefaultAttributeValue($this);
  1803.                     }
  1805.                     if (isset($ids[$a->getId()])) {
  1806.                         foreach ($a->getAttributeValue($this) as $av) {
  1807.                             if ($av->getId() === (int) $ids[$a->getId()]) {
  1808.                                 $attributeValues[$a->getId()] = $av;
  1809.                                 break;
  1810.                             }
  1811.                         }
  1812.                     }
  1813.                 }
  1814.             }
  1816.             return $attributeValues;
  1817.         }, ['prepareAttributeValues', $ids]);
  1818.     }
  1820.     /**
  1821.      * Define the specific clone name for the product
  1822.      *
  1823.      * @param string $name Product name
  1824.      *
  1825.      * @return string
  1826.      */
  1827.     protected function getCloneName($name)
  1828.     {
  1829.         return $name . ' [ clone ]';
  1830.     }
  1832.     /**
  1833.      * Preprocess change product class
  1834.      *
  1835.      * @return void
  1836.      */
  1837.     protected function preprocessChangeProductClass()
  1838.     {
  1839.         if ($this->productClass) {
  1840.             foreach ($this->productClass->getAttributes() as $a) {
  1841.                 $class = $a->getAttributeValueClass($a->getType());
  1842.                 $repo  = \XLite\Core\Database::getRepo($class);
  1843.                 foreach ($repo->findBy(['product' => $this, 'attribute' => $a]) as $v) {
  1844.                     $repo->delete($v);
  1845.                 }
  1846.             }
  1847.         }
  1848.     }
  1850.     /**
  1851.      * Return certain Product <--> Category association
  1852.      *
  1853.      * @param integer|null $categoryId Category ID
  1854.      *
  1855.      * @return \XLite\Model\CategoryProducts|void
  1856.      */
  1857.     protected function findLinkByCategoryId($categoryId)
  1858.     {
  1859.         $result = null;
  1861.         foreach ($this->getCategoryProducts() as $cp) {
  1862.             if ($cp->getCategory() && $cp->getCategory()->getCategoryId() == $categoryId) {
  1863.                 $result = $cp;
  1864.             }
  1865.         }
  1867.         return $result;
  1868.     }
  1870.     /**
  1871.      * Return certain Product <--> Category association
  1872.      *
  1873.      * @param integer|null $categoryId Category ID OPTIONAL
  1874.      *
  1875.      * @return \XLite\Model\CategoryProducts
  1876.      */
  1877.     protected function getLink($categoryId = null)
  1878.     {
  1879.         $result = empty($categoryId)
  1880.             ? $this->getCategoryProducts()->first()
  1881.             : $this->findLinkByCategoryId($categoryId);
  1883.         if (empty($result)) {
  1884.             $result = new \XLite\Model\CategoryProducts();
  1885.         }
  1887.         return $result;
  1888.     }
  1890.     /**
  1891.      * Returns position of the product in the given category
  1892.      *
  1893.      * @param integer $category
  1894.      *
  1895.      * @return integer
  1896.      */
  1897.     public function getPosition($category)
  1898.     {
  1899.         return $this->getOrderBy($category);
  1900.     }
  1902.     /**
  1903.      * Sets the position of the product in the given category
  1904.      *
  1905.      * @param array $value
  1906.      *
  1907.      * @return void
  1908.      */
  1909.     public function setPosition($value)
  1910.     {
  1911.         $link = $this->getLink($value['category']);
  1912.         $link->setProduct($this);
  1913.         $link->setOrderby($value['position']);
  1915.         \XLite\Core\Database::getEM()->persist($link);
  1916.         \XLite\Core\Database::getEM()->flush($link);
  1917.     }
  1919.     /**
  1920.      * Returns meta description
  1921.      *
  1922.      * @return string
  1923.      */
  1924.     public function getMetaDesc()
  1925.     {
  1926.         return $this->getMetaDescType() === static::META_DESC_TYPE_AUTO
  1927.             ? static::generateMetaDescription($this->getCommonDescription())
  1928.             : $this->getSoftTranslation()->getMetaDesc();
  1929.     }
  1931.     /**
  1932.      * Generate meta description
  1933.      *
  1934.      * @param $description
  1935.      *
  1936.      * @return string
  1937.      */
  1938.     public static function generateMetaDescription($description)
  1939.     {
  1940.         return static::postprocessMetaDescription($description);
  1941.     }
  1943.     /**
  1944.      * Returns meta description type
  1945.      *
  1946.      * @return string
  1947.      */
  1948.     public function getMetaDescType()
  1949.     {
  1950.         $result = $this->metaDescType;
  1952.         if (!$result) {
  1953.             $metaDescPresent = array_reduce($this->getTranslations()->toArray(), static function ($carry, $item) {
  1954.                 return $carry ?: (bool) $item->getMetaDesc();
  1955.             }, false);
  1957.             $result = $metaDescPresent
  1958.                 ? static::META_DESC_TYPE_CUSTOM
  1959.                 : static::META_DESC_TYPE_AUTO;
  1960.         }
  1962.         return $result;
  1963.     }
  1965.     // {{{ Sales statistics
  1967.     /**
  1968.      * Set sales
  1969.      *
  1970.      * @param integer $sales Sales
  1971.      */
  1972.     public function setSales($sales)
  1973.     {
  1974.         $this->sales = max(0, $sales);
  1975.     }
  1977.     /**
  1978.      * Return sales
  1979.      *
  1980.      * @return integer
  1981.      */
  1982.     public function getSales()
  1983.     {
  1984.         return $this->sales;
  1985.     }
  1987.     /**
  1988.      * Update sales
  1989.      */
  1990.     public function updateSales()
  1991.     {
  1992.         $this->setSales(
  1993.             $this->getRepository()->findSalesByProduct($this)
  1994.         );
  1995.     }
  1997.     // }}}
  1999.     /**
  2000.      * Get product_id
  2001.      *
  2002.      * @return integer
  2003.      */
  2004.     public function getProductId()
  2005.     {
  2006.         return $this->product_id;
  2007.     }
  2009.     /**
  2010.      * Set price
  2011.      *
  2012.      * @param float $price
  2013.      *
  2014.      * @return Product
  2015.      */
  2016.     public function setPrice($price)
  2017.     {
  2018.         $this->price = Converter::toUnsigned32BitFloat($price);
  2020.         return $this;
  2021.     }
  2023.     /**
  2024.      * Set enabled
  2025.      *
  2026.      * @param boolean $enabled
  2027.      *
  2028.      * @return Product
  2029.      */
  2030.     public function setEnabled($enabled)
  2031.     {
  2032.         $this->enabled = (bool) $enabled;
  2034.         return $this;
  2035.     }
  2037.     /**
  2038.      * Get enabled
  2039.      *
  2040.      * @return boolean
  2041.      */
  2042.     public function getEnabled()
  2043.     {
  2044.         return $this->enabled;
  2045.     }
  2047.     /**
  2048.      * Set weight
  2049.      *
  2050.      * @param float $weight
  2051.      *
  2052.      * @return Product
  2053.      */
  2054.     public function setWeight($weight)
  2055.     {
  2056.         $this->weight = Converter::toUnsigned32BitFloat($weight);
  2058.         return $this;
  2059.     }
  2061.     /**
  2062.      * Set useSeparateBox
  2063.      *
  2064.      * @param boolean $useSeparateBox
  2065.      *
  2066.      * @return Product
  2067.      */
  2068.     public function setUseSeparateBox($useSeparateBox)
  2069.     {
  2070.         $this->useSeparateBox = $useSeparateBox;
  2072.         return $this;
  2073.     }
  2075.     /**
  2076.      * Get useSeparateBox
  2077.      *
  2078.      * @return boolean
  2079.      */
  2080.     public function getUseSeparateBox()
  2081.     {
  2082.         return $this->useSeparateBox;
  2083.     }
  2085.     /**
  2086.      * Set boxWidth
  2087.      *
  2088.      * @param float $boxWidth
  2089.      *
  2090.      * @return Product
  2091.      */
  2092.     public function setBoxWidth($boxWidth)
  2093.     {
  2094.         $this->boxWidth = Converter::toUnsigned32BitFloat($boxWidth);
  2096.         return $this;
  2097.     }
  2099.     /**
  2100.      * Get boxWidth
  2101.      *
  2102.      * @return float
  2103.      */
  2104.     public function getBoxWidth()
  2105.     {
  2106.         return $this->boxWidth;
  2107.     }
  2109.     /**
  2110.      * Set boxLength
  2111.      *
  2112.      * @param float $boxLength
  2113.      *
  2114.      * @return Product
  2115.      */
  2116.     public function setBoxLength($boxLength)
  2117.     {
  2118.         $this->boxLength = Converter::toUnsigned32BitFloat($boxLength);
  2120.         return $this;
  2121.     }
  2123.     /**
  2124.      * Get boxLength
  2125.      *
  2126.      * @return float
  2127.      */
  2128.     public function getBoxLength()
  2129.     {
  2130.         return $this->boxLength;
  2131.     }
  2133.     /**
  2134.      * Set boxHeight
  2135.      *
  2136.      * @param float $boxHeight
  2137.      *
  2138.      * @return Product
  2139.      */
  2140.     public function setBoxHeight($boxHeight)
  2141.     {
  2142.         $this->boxHeight = Converter::toUnsigned32BitFloat($boxHeight);
  2144.         return $this;
  2145.     }
  2147.     /**
  2148.      * Get boxHeight
  2149.      *
  2150.      * @return float
  2151.      */
  2152.     public function getBoxHeight()
  2153.     {
  2154.         return $this->boxHeight;
  2155.     }
  2157.     /**
  2158.      * Set itemsPerBox
  2159.      *
  2160.      * @param integer $itemsPerBox
  2161.      *
  2162.      * @return Product
  2163.      */
  2164.     public function setItemsPerBox($itemsPerBox)
  2165.     {
  2166.         $this->itemsPerBox = Converter::toUnsigned32BitInt($itemsPerBox);
  2168.         return $this;
  2169.     }
  2171.     /**
  2172.      * Get itemsPerBox
  2173.      *
  2174.      * @return integer
  2175.      */
  2176.     public function getItemsPerBox()
  2177.     {
  2178.         return $this->itemsPerBox;
  2179.     }
  2181.     /**
  2182.      * Set free_shipping
  2183.      *
  2184.      * @param boolean $freeShipping
  2185.      *
  2186.      * @return Product
  2187.      */
  2188.     public function setFreeShipping($freeShipping)
  2189.     {
  2190.         $this->free_shipping = (bool) $freeShipping;
  2192.         return $this;
  2193.     }
  2195.     /**
  2196.      * Set taxable
  2197.      *
  2198.      * @param boolean $taxable
  2199.      *
  2200.      * @return Product
  2201.      */
  2202.     public function setTaxable($taxable)
  2203.     {
  2204.         $this->taxable = $taxable;
  2206.         return $this;
  2207.     }
  2209.     /**
  2210.      * Get taxable
  2211.      *
  2212.      * @return boolean
  2213.      */
  2214.     public function getTaxable()
  2215.     {
  2216.         return $this->taxable;
  2217.     }
  2219.     /**
  2220.      * Set arrivalDate
  2221.      *
  2222.      * @param integer $arrivalDate
  2223.      *
  2224.      * @return Product
  2225.      */
  2226.     public function setArrivalDate($arrivalDate)
  2227.     {
  2228.         $this->arrivalDate = min(MAX_TIMESTAMP, max(0, $arrivalDate));
  2230.         return $this;
  2231.     }
  2233.     /**
  2234.      * Get arrivalDate
  2235.      *
  2236.      * @return integer
  2237.      */
  2238.     public function getArrivalDate()
  2239.     {
  2240.         return $this->arrivalDate;
  2241.     }
  2243.     /**
  2244.      * Returns true if product is classified as an upcoming product
  2245.      *
  2246.      * @return boolean
  2247.      */
  2248.     public function isUpcomingProduct()
  2249.     {
  2250.         return $this->getArrivalDate()
  2251.             && $this->getArrivalDate() > Converter::getDayEnd(static::getUserTime());
  2252.     }
  2254.     /**
  2255.      * Check if upcoming product is available
  2256.      *
  2257.      * @return boolean
  2258.      */
  2259.     public function isAllowedUpcomingProduct()
  2260.     {
  2261.         return false;
  2262.     }
  2264.     /**
  2265.      * Set date
  2266.      *
  2267.      * @param integer $date
  2268.      *
  2269.      * @return Product
  2270.      */
  2271.     public function setDate($date)
  2272.     {
  2273.         $this->date = $date;
  2275.         return $this;
  2276.     }
  2278.     /**
  2279.      * Get date
  2280.      *
  2281.      * @return integer
  2282.      */
  2283.     public function getDate()
  2284.     {
  2285.         return $this->date;
  2286.     }
  2288.     /**
  2289.      * Set updateDate
  2290.      *
  2291.      * @param integer $updateDate
  2292.      *
  2293.      * @return Product
  2294.      */
  2295.     public function setUpdateDate($updateDate)
  2296.     {
  2297.         $this->updateDate = $updateDate;
  2299.         return $this;
  2300.     }
  2302.     /**
  2303.      * Get updateDate
  2304.      *
  2305.      * @return integer
  2306.      */
  2307.     public function getUpdateDate()
  2308.     {
  2309.         return $this->updateDate;
  2310.     }
  2312.     /**
  2313.      * Set needProcess
  2314.      *
  2315.      * @param boolean $needProcess
  2316.      *
  2317.      * @return Product
  2318.      */
  2319.     public function setNeedProcess($needProcess)
  2320.     {
  2321.         $this->needProcess = $needProcess;
  2323.         return $this;
  2324.     }
  2326.     /**
  2327.      * Get needProcess
  2328.      *
  2329.      * @return boolean
  2330.      */
  2331.     public function getNeedProcess()
  2332.     {
  2333.         return $this->needProcess;
  2334.     }
  2336.     /**
  2337.      * Set attrSepTab
  2338.      *
  2339.      * @param boolean $attrSepTab
  2340.      *
  2341.      * @return Product
  2342.      */
  2343.     public function setAttrSepTab($attrSepTab)
  2344.     {
  2345.         $this->attrSepTab = $attrSepTab;
  2347.         return $this;
  2348.     }
  2350.     /**
  2351.      * Get attrSepTab
  2352.      *
  2353.      * @return boolean
  2354.      */
  2355.     public function getAttrSepTab()
  2356.     {
  2357.         return $this->attrSepTab;
  2358.     }
  2360.     /**
  2361.      * Set metaDescType
  2362.      *
  2363.      * @param string $metaDescType
  2364.      *
  2365.      * @return Product
  2366.      */
  2367.     public function setMetaDescType($metaDescType)
  2368.     {
  2369.         $this->metaDescType = $metaDescType;
  2371.         return $this;
  2372.     }
  2374.     /**
  2375.      * Set xcPendingExport
  2376.      *
  2377.      * @param boolean $xcPendingExport
  2378.      *
  2379.      * @return Product
  2380.      */
  2381.     public function setXcPendingExport($xcPendingExport)
  2382.     {
  2383.         $this->xcPendingExport = $xcPendingExport;
  2385.         return $this;
  2386.     }
  2388.     /**
  2389.      * Get xcPendingExport
  2390.      *
  2391.      * @return boolean
  2392.      */
  2393.     public function getXcPendingExport()
  2394.     {
  2395.         return $this->xcPendingExport;
  2396.     }
  2398.     /**
  2399.      * Add categoryProducts
  2400.      *
  2401.      * @param \XLite\Model\CategoryProducts $categoryProducts
  2402.      *
  2403.      * @return Product
  2404.      */
  2405.     public function addCategoryProducts(\XLite\Model\CategoryProducts $categoryProducts)
  2406.     {
  2407.         $this->categoryProducts[] = $categoryProducts;
  2409.         return $this;
  2410.     }
  2412.     /**
  2413.      * Get categoryProducts
  2414.      *
  2415.      * @return \Doctrine\Common\Collections\Collection
  2416.      */
  2417.     public function getCategoryProducts()
  2418.     {
  2419.         return $this->categoryProducts;
  2420.     }
  2422.     /**
  2423.      * @param \XLite\Model\Category[] $categories
  2424.      */
  2425.     public function addCategoryProductsLinksByCategories($categories)
  2426.     {
  2427.         foreach ($categories as $category) {
  2428.             if (!$this->hasCategoryProductsLinkByCategory($category)) {
  2429.                 $categoryProduct = new \XLite\Model\CategoryProducts();
  2430.                 $categoryProduct->setProduct($this);
  2431.                 $categoryProduct->setCategory($category);
  2433.                 $this->addCategoryProducts($categoryProduct);
  2434.             }
  2435.         }
  2436.     }
  2438.     /**
  2439.      * @param \XLite\Model\Category $category
  2440.      */
  2441.     public function addCategory($category)
  2442.     {
  2443.         $categoryProduct = new \XLite\Model\CategoryProducts();
  2444.         $categoryProduct->setProduct($this);
  2445.         $categoryProduct->setCategory($category);
  2447.         $this->addCategoryProducts($categoryProduct);
  2448.     }
  2450.     /**
  2451.      * @param \XLite\Model\Category[] $categories
  2452.      */
  2453.     public function removeCategoryProductsLinksByCategories($categories)
  2454.     {
  2455.         $categoryProductsLinks = [];
  2457.         foreach ($categories as $category) {
  2458.             $categoryProductsLink = $this->findCategoryProductsLinkByCategory($category);
  2459.             if ($categoryProductsLink) {
  2460.                 $categoryProductsLinks[] = $categoryProductsLink;
  2461.             }
  2462.         }
  2464.         if ($categoryProductsLinks) {
  2465.             \XLite\Core\Database::getRepo('XLite\Model\CategoryProducts')->deleteInBatch(
  2466.                 $categoryProductsLinks
  2467.             );
  2468.         }
  2469.     }
  2471.     /**
  2472.      * @param \XLite\Model\Category[] $categories
  2473.      */
  2474.     public function replaceCategoryProductsLinksByCategories($categories)
  2475.     {
  2476.         $categoriesToAdd = [];
  2477.         foreach ($categories as $category) {
  2478.             if (!$this->hasCategoryProductsLinkByCategory($category)) {
  2479.                 $categoriesToAdd[] = $category;
  2480.             }
  2481.         }
  2483.         $categoriesIds = array_map(static function ($item) {
  2484.             /** @var \XLite\Model\Category $item */
  2485.             return (int) $item->getCategoryId();
  2486.         }, $categories);
  2488.         $categoryProductsLinksToDelete = [];
  2489.         foreach ($this->getCategoryProducts() as $categoryProduct) {
  2490.             if (!in_array((int) $categoryProduct->getCategory()->getCategoryId(), $categoriesIds, true)) {
  2491.                 $categoryProductsLinksToDelete[] = $categoryProduct;
  2492.             }
  2493.         }
  2495.         if ($categoryProductsLinksToDelete) {
  2496.             \XLite\Core\Database::getRepo('XLite\Model\CategoryProducts')->deleteInBatch(
  2497.                 $categoryProductsLinksToDelete
  2498.             );
  2499.         }
  2501.         if ($categoriesToAdd) {
  2502.             $this->addCategoryProductsLinksByCategories($categoriesToAdd);
  2503.         }
  2504.     }
  2506.     /**
  2507.      * @param \XLite\Model\Category $category
  2508.      *
  2509.      * @return bool
  2510.      */
  2511.     public function hasCategoryProductsLinkByCategory($category)
  2512.     {
  2513.         return (bool) $this->findCategoryProductsLinkByCategory($category);
  2514.     }
  2516.     /**
  2517.      * @param \XLite\Model\Category $category
  2518.      *
  2519.      * @return \XLite\Model\CategoryProducts
  2520.      */
  2521.     public function findCategoryProductsLinkByCategory($category)
  2522.     {
  2523.         /** @var \XLite\Model\CategoryProducts $categoryProduct */
  2524.         foreach ($this->getCategoryProducts() as $categoryProduct) {
  2525.             if ((int) $categoryProduct->getCategory()->getCategoryId() === (int) $category->getCategoryId()) {
  2526.                 return $categoryProduct;
  2527.             }
  2528.         }
  2530.         return null;
  2531.     }
  2533.     /**
  2534.      * Add order_items
  2535.      *
  2536.      * @param \XLite\Model\OrderItem $orderItems
  2537.      *
  2538.      * @return Product
  2539.      */
  2540.     public function addOrderItems(\XLite\Model\OrderItem $orderItems)
  2541.     {
  2542.         $this->order_items[] = $orderItems;
  2544.         return $this;
  2545.     }
  2547.     /**
  2548.      * Get order_items
  2549.      *
  2550.      * @return \Doctrine\Common\Collections\Collection
  2551.      */
  2552.     public function getOrderItems()
  2553.     {
  2554.         return $this->order_items;
  2555.     }
  2557.     /**
  2558.      * Add images
  2559.      *
  2560.      * @param \XLite\Model\Image\Product\Image $images
  2561.      *
  2562.      * @return Product
  2563.      */
  2564.     public function addImages(\XLite\Model\Image\Product\Image $images)
  2565.     {
  2566.         $this->images[] = $images;
  2568.         return $this;
  2569.     }
  2571.     /**
  2572.      * Get images
  2573.      *
  2574.      * @return \Doctrine\Common\Collections\Collection
  2575.      */
  2576.     public function getImages()
  2577.     {
  2578.         return $this->images;
  2579.     }
  2581.     /**
  2582.      * Get productClass
  2583.      *
  2584.      * @return \XLite\Model\ProductClass
  2585.      */
  2586.     public function getProductClass()
  2587.     {
  2588.         return $this->productClass;
  2589.     }
  2591.     /**
  2592.      * Set taxClass
  2593.      *
  2594.      * @param \XLite\Model\TaxClass $taxClass
  2595.      *
  2596.      * @return Product
  2597.      */
  2598.     public function setTaxClass(\XLite\Model\TaxClass $taxClass = null)
  2599.     {
  2600.         $this->taxClass = $taxClass;
  2602.         return $this;
  2603.     }
  2605.     /**
  2606.      * Get taxClass
  2607.      *
  2608.      * @return \XLite\Model\TaxClass
  2609.      */
  2610.     public function getTaxClass()
  2611.     {
  2612.         return $this->taxClass;
  2613.     }
  2615.     /**
  2616.      * Add attributes
  2617.      *
  2618.      * @param \XLite\Model\Attribute $attributes
  2619.      *
  2620.      * @return Product
  2621.      */
  2622.     public function addAttributes(\XLite\Model\Attribute $attributes)
  2623.     {
  2624.         $this->attributes[] = $attributes;
  2626.         return $this;
  2627.     }
  2629.     /**
  2630.      * Get attributes
  2631.      *
  2632.      * @return \Doctrine\Common\Collections\Collection<int, \XLite\Model\Attribute>
  2633.      */
  2634.     public function getAttributes()
  2635.     {
  2636.         return $this->attributes;
  2637.     }
  2639.     /**
  2640.      * Add attributeValueC
  2641.      *
  2642.      * @param \XLite\Model\AttributeValue\AttributeValueCheckbox $attributeValueC
  2643.      *
  2644.      * @return Product
  2645.      */
  2646.     public function addAttributeValueC(\XLite\Model\AttributeValue\AttributeValueCheckbox $attributeValueC)
  2647.     {
  2648.         $this->attributeValueC[] = $attributeValueC;
  2650.         return $this;
  2651.     }
  2653.     /**
  2654.      * Get attributeValueC
  2655.      *
  2656.      * @return \Doctrine\Common\Collections\Collection
  2657.      */
  2658.     public function getAttributeValueC()
  2659.     {
  2660.         return $this->attributeValueC;
  2661.     }
  2663.     /**
  2664.      * Add attributeValueT
  2665.      *
  2666.      * @param \XLite\Model\AttributeValue\AttributeValueText $attributeValueT
  2667.      *
  2668.      * @return Product
  2669.      */
  2670.     public function addAttributeValueT(\XLite\Model\AttributeValue\AttributeValueText $attributeValueT)
  2671.     {
  2672.         $this->attributeValueT[] = $attributeValueT;
  2674.         return $this;
  2675.     }
  2677.     /**
  2678.      * Get attributeValueT
  2679.      *
  2680.      * @return \Doctrine\Common\Collections\Collection
  2681.      */
  2682.     public function getAttributeValueT()
  2683.     {
  2684.         return $this->attributeValueT;
  2685.     }
  2687.     /**
  2688.      * Add attributeValueS
  2689.      *
  2690.      * @param \XLite\Model\AttributeValue\AttributeValueSelect $attributeValueS
  2691.      *
  2692.      * @return Product
  2693.      */
  2694.     public function addAttributeValueS(\XLite\Model\AttributeValue\AttributeValueSelect $attributeValueS)
  2695.     {
  2696.         $this->attributeValueS[] = $attributeValueS;
  2698.         return $this;
  2699.     }
  2701.     /**
  2702.      * Get attributeValueS
  2703.      *
  2704.      * @return \Doctrine\Common\Collections\Collection
  2705.      */
  2706.     public function getAttributeValueS()
  2707.     {
  2708.         return $this->attributeValueS;
  2709.     }
  2711.     /**
  2712.      * Add attributeValueH
  2713.      *
  2714.      * @param \XLite\Model\AttributeValue\AttributeValueHidden $attributeValueH
  2715.      *
  2716.      * @return Product
  2717.      */
  2718.     public function addAttributeValueH(\XLite\Model\AttributeValue\AttributeValueHidden $attributeValueH)
  2719.     {
  2720.         $this->attributeValueH[] = $attributeValueH;
  2722.         return $this;
  2723.     }
  2725.     /**
  2726.      * Get attributeValueH
  2727.      *
  2728.      * @return \Doctrine\Common\Collections\Collection
  2729.      */
  2730.     public function getAttributeValueH()
  2731.     {
  2732.         return $this->attributeValueH;
  2733.     }
  2735.     /**
  2736.      * Add quickData
  2737.      *
  2738.      * @param \XLite\Model\QuickData $quickData
  2739.      *
  2740.      * @return Product
  2741.      */
  2742.     public function addQuickData(\XLite\Model\QuickData $quickData)
  2743.     {
  2744.         $this->quickData[] = $quickData;
  2746.         return $this;
  2747.     }
  2749.     /**
  2750.      * Get quickData
  2751.      *
  2752.      * @return \Doctrine\Common\Collections\Collection
  2753.      */
  2754.     public function getQuickData()
  2755.     {
  2756.         return $this->quickData;
  2757.     }
  2759.     /**
  2760.      * Add memberships
  2761.      *
  2762.      * @param \XLite\Model\Membership $memberships
  2763.      *
  2764.      * @return Product
  2765.      */
  2766.     public function addMemberships(\XLite\Model\Membership $memberships)
  2767.     {
  2768.         $this->memberships[] = $memberships;
  2770.         return $this;
  2771.     }
  2773.     /**
  2774.      * Get memberships
  2775.      *
  2776.      * @return \Doctrine\Common\Collections\Collection
  2777.      */
  2778.     public function getMemberships()
  2779.     {
  2780.         return $this->memberships;
  2781.     }
  2783.     /**
  2784.      * @param \XLite\Model\Membership[] $memberships
  2785.      */
  2786.     public function addMembershipsByMemberships($memberships)
  2787.     {
  2788.         foreach ($memberships as $membership) {
  2789.             if (!$this->hasMembershipByMembership($membership)) {
  2790.                 $this->addMemberships($membership);
  2791.             }
  2792.         }
  2793.     }
  2795.     /**
  2796.      * @param \XLite\Model\Membership[] $memberships
  2797.      */
  2798.     public function removeMembershipsByMemberships($memberships)
  2799.     {
  2800.         foreach ($memberships as $membership) {
  2801.             if ($this->hasMembershipByMembership($membership)) {
  2802.                 $this->getMemberships()->removeElement($membership);
  2803.             }
  2804.         }
  2805.     }
  2807.     /**
  2808.      * @param \XLite\Model\Membership[] $memberships
  2809.      */
  2810.     public function replaceMembershipsByMemberships($memberships)
  2811.     {
  2812.         $ids = array_map(static function ($item) {
  2813.             /** @var \XLite\Model\Membership $item */
  2814.             return (int) $item->getMembershipId();
  2815.         }, $memberships);
  2817.         $toRemove = [];
  2818.         foreach ($this->getMemberships() as $membership) {
  2819.             if (!in_array((int) $membership->getMembershipId(), $ids, true)) {
  2820.                 $toRemove[] = $membership;
  2821.             }
  2822.         }
  2824.         $this->addMembershipsByMemberships($memberships);
  2825.         $this->removeMembershipsByMemberships($toRemove);
  2826.     }
  2828.     /**
  2829.      * @param \XLite\Model\Membership $membership
  2830.      *
  2831.      * @return boolean
  2832.      */
  2833.     public function hasMembershipByMembership($membership)
  2834.     {
  2835.         return (bool) $this->getMembershipByMembership($membership);
  2836.     }
  2838.     /**
  2839.      * @param \XLite\Model\Membership $membership
  2840.      *
  2841.      * @return mixed|null
  2842.      */
  2843.     public function getMembershipByMembership($membership)
  2844.     {
  2845.         foreach ($this->getMemberships() as $membershipObject) {
  2846.             if (
  2847.                 (
  2848.                     $membership->isPersistent()
  2849.                     && (int) $membership->getMembershipId() === (int) $membershipObject->getMembershipId()
  2850.                 )
  2851.                 || $membership === $membershipObject
  2852.             ) {
  2853.                 return $membershipObject;
  2854.             }
  2855.         }
  2857.         return null;
  2858.     }
  2860.     /**
  2861.      * Add cleanURLs
  2862.      *
  2863.      * @param \XLite\Model\CleanURL $cleanURLs
  2864.      *
  2865.      * @return Product
  2866.      */
  2867.     public function addCleanURLs(\XLite\Model\CleanURL $cleanURLs)
  2868.     {
  2869.         $this->cleanURLs[] = $cleanURLs;
  2871.         return $this;
  2872.     }
  2874.     /**
  2875.      * Get cleanURLs
  2876.      *
  2877.      * @return \Doctrine\Common\Collections\Collection
  2878.      */
  2879.     public function getCleanURLs()
  2880.     {
  2881.         return $this->cleanURLs;
  2882.     }
  2884.     /**
  2885.      * Set inventoryEnabled
  2886.      *
  2887.      * @param boolean $inventoryEnabled
  2888.      *
  2889.      * @return Product
  2890.      */
  2891.     public function setInventoryEnabled($inventoryEnabled)
  2892.     {
  2893.         $this->inventoryEnabled = $inventoryEnabled;
  2895.         return $this;
  2896.     }
  2898.     /**
  2899.      * Get inventoryEnabled
  2900.      *
  2901.      * @return boolean
  2902.      */
  2903.     public function getInventoryEnabled()
  2904.     {
  2905.         return $this->inventoryEnabled;
  2906.     }
  2908.     /**
  2909.      * Get amount
  2910.      *
  2911.      * @return integer
  2912.      */
  2913.     public function getAmount()
  2914.     {
  2915.         return $this->amount;
  2916.     }
  2918.     /**
  2919.      * Set lowLimitEnabledCustomer
  2920.      *
  2921.      * @param boolean $lowLimitEnabledCustomer
  2922.      *
  2923.      * @return Product
  2924.      */
  2925.     public function setLowLimitEnabledCustomer($lowLimitEnabledCustomer)
  2926.     {
  2927.         $this->lowLimitEnabledCustomer = $lowLimitEnabledCustomer;
  2929.         return $this;
  2930.     }
  2932.     /**
  2933.      * Get lowLimitEnabledCustomer
  2934.      *
  2935.      * @return boolean
  2936.      */
  2937.     public function getLowLimitEnabledCustomer()
  2938.     {
  2939.         return $this->lowLimitEnabledCustomer;
  2940.     }
  2942.     /**
  2943.      * Set lowLimitEnabled
  2944.      *
  2945.      * @param boolean $lowLimitEnabled
  2946.      *
  2947.      * @return Product
  2948.      */
  2949.     public function setLowLimitEnabled($lowLimitEnabled)
  2950.     {
  2951.         $this->lowLimitEnabled = $lowLimitEnabled;
  2953.         return $this;
  2954.     }
  2956.     /**
  2957.      * Get lowLimitEnabled
  2958.      *
  2959.      * @return boolean
  2960.      */
  2961.     public function getLowLimitEnabled()
  2962.     {
  2963.         return $this->lowLimitEnabled;
  2964.     }
  2966.     /**
  2967.      * Get lowLimitAmount
  2968.      *
  2969.      * @return integer
  2970.      */
  2971.     public function getLowLimitAmount()
  2972.     {
  2973.         return $this->lowLimitAmount;
  2974.     }
  2976.     /**
  2977.      * @return integer
  2978.      */
  2979.     protected function getAvailableAmountForTooltipText()
  2980.     {
  2981.         return $this->getAvailableAmount();
  2982.     }
  2984.     /**
  2985.      * Get help text for "all stock in cart" product
  2986.      *
  2987.      * @return string
  2988.      */
  2989.     public function getAllStockInCartTooltipText()
  2990.     {
  2991.         $text = '';
  2993.         if ($this->getInventoryEnabled()) {
  2994.             $text = static::t(
  2995.                 'Sorry, we only have {{qty}} of that item available',
  2996.                 ['qty' => $this->getAvailableAmountForTooltipText()]
  2997.             );
  2998.         }
  3000.         return $text;
  3001.     }
  3003.     // {{{ Translation Getters / setters
  3005.     /**
  3006.      * @return string
  3007.      */
  3008.     public function getDescription()
  3009.     {
  3010.         return $this->getTranslationField(__FUNCTION__);
  3011.     }
  3013.     /**
  3014.      * @param string $description
  3015.      *
  3016.      * @return \XLite\Model\Base\Translation
  3017.      */
  3018.     public function setDescription($description)
  3019.     {
  3020.         return $this->setTranslationField(__FUNCTION__, $description);
  3021.     }
  3023.     /**
  3024.      * @return string
  3025.      */
  3026.     public function getBriefDescription()
  3027.     {
  3028.         return $this->getTranslationField(__FUNCTION__);
  3029.     }
  3031.     /**
  3032.      * @param string $briefDescription
  3033.      *
  3034.      * @return \XLite\Model\Base\Translation
  3035.      */
  3036.     public function setBriefDescription($briefDescription)
  3037.     {
  3038.         return $this->setTranslationField(__FUNCTION__, $briefDescription);
  3039.     }
  3041.     /**
  3042.      * @return string
  3043.      */
  3044.     public function getMetaTags()
  3045.     {
  3046.         return $this->getTranslationField(__FUNCTION__);
  3047.     }
  3049.     /**
  3050.      * @param string $metaTags
  3051.      *
  3052.      * @return \XLite\Model\Base\Translation
  3053.      */
  3054.     public function setMetaTags($metaTags)
  3055.     {
  3056.         return $this->setTranslationField(__FUNCTION__, $metaTags);
  3057.     }
  3059.     /**
  3060.      * @param string $metaDesc
  3061.      *
  3062.      * @return \XLite\Model\Base\Translation
  3063.      */
  3064.     public function setMetaDesc($metaDesc)
  3065.     {
  3066.         return $this->setTranslationField(__FUNCTION__, $metaDesc);
  3067.     }
  3069.     /**
  3070.      * @return string
  3071.      */
  3072.     public function getMetaTitle()
  3073.     {
  3074.         return $this->getTranslationField(__FUNCTION__);
  3075.     }
  3077.     /**
  3078.      * @param string $metaTitle
  3079.      *
  3080.      * @return \XLite\Model\Base\Translation
  3081.      */
  3082.     public function setMetaTitle($metaTitle)
  3083.     {
  3084.         return $this->setTranslationField(__FUNCTION__, $metaTitle);
  3085.     }
  3087.     // }}}
  3089.     public function isDemoProduct(): bool
  3090.     {
  3091.         return $this->isDemoProduct;
  3092.     }
  3094.     public function setIsDemoProduct(bool $isDemoProduct): self
  3095.     {
  3096.         $this->isDemoProduct = $isDemoProduct;
  3098.         return $this;
  3099.     }
  3100. }