vendor/isotope/isotope-core/system/modules/isotope/library/Isotope/Model/ProductCollection.php line 131

Open in your IDE?
  1. <?php
  3. /*
  4.  * Isotope eCommerce for Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2009 - 2019 terminal42 gmbh & Isotope eCommerce Workgroup
  7.  *
  8.  * @link       https://isotopeecommerce.org
  9.  * @license    https://opensource.org/licenses/lgpl-3.0.html
  10.  */
  12. namespace Isotope\Model;
  14. use Contao\Controller;
  15. use Contao\Database;
  16. use Contao\MemberModel;
  17. use Contao\StringUtil;
  18. use Contao\System;
  19. use Contao\Template;
  20. use Haste\Generator\RowClass;
  21. use Haste\Units\Mass\Scale;
  22. use Haste\Units\Mass\Weighable;
  23. use Haste\Units\Mass\WeightAggregate;
  24. use Haste\Util\Format;
  25. use Isotope\Frontend;
  26. use Isotope\Interfaces\IsotopeAttribute;
  27. use Isotope\Interfaces\IsotopeOrderableCollection;
  28. use Isotope\Interfaces\IsotopePayment;
  29. use Isotope\Interfaces\IsotopeProduct;
  30. use Isotope\Interfaces\IsotopeProductCollection;
  31. use Isotope\Interfaces\IsotopeShipping;
  32. use Isotope\Isotope;
  33. use Isotope\Message;
  34. use Isotope\Model\Gallery\Standard as StandardGallery;
  35. use Isotope\Model\ProductCollectionSurcharge\Tax;
  36. use Model\Registry;
  38. /**
  39.  * Class ProductCollection
  40.  *
  41.  * @property int    $id
  42.  * @property int    $tstamp
  43.  * @property string $type
  44.  * @property int    $member
  45.  * @property int    $store_id
  46.  * @property int    $locked
  47.  * @property mixed  $settings
  48.  * @property int    $source_collection_id
  49.  * @property string $uniqid
  50.  * @property int    $config_id
  51.  * @property int    $payment_id
  52.  * @property int    $shipping_id
  53.  * @property int    $billing_address_id
  54.  * @property int    $shipping_address_id
  55.  * @property float  $subtotal
  56.  * @property float  $tax_free_subtotal
  57.  * @property float  $total
  58.  * @property float  $tax_free_total
  59.  * @property string $currency
  60.  * @property string $language
  61.  *
  62.  * @property int|array $nc_notification
  63.  * @property bool      $iso_addToAddressbook
  64.  * @property array     $iso_checkout_skippable
  65.  * @property array     $email_data
  66.  * @property int       $orderdetails_page
  67.  */
  68. abstract class ProductCollection extends TypeAgent implements IsotopeProductCollection
  69. {
  71.     /**
  72.      * Name of the current table
  73.      * @var string
  74.      */
  75.     protected static $strTable = 'tl_iso_product_collection';
  77.     /**
  78.      * Interface to validate product collection
  79.      * @var string
  80.      */
  81.     protected static $strInterface = '\Isotope\Interfaces\IsotopeProductCollection';
  83.     /**
  84.      * List of types (classes) for this model
  85.      * @var array
  86.      */
  87.     protected static $arrModelTypes = array();
  89.     /**
  90.      * Cache
  91.      * @var array
  92.      */
  93.     protected $arrCache;
  95.     /**
  96.      * Cache product items in this collection
  97.      * @var ProductCollectionItem[]
  98.      */
  99.     protected $arrItems;
  101.     /**
  102.      * Cache surcharges in this collection
  103.      * @var array
  104.      */
  105.     protected $arrSurcharges;
  107.     /**
  108.      * Errors
  109.      * @var array
  110.      */
  111.     protected $arrErrors = array();
  113.     /**
  114.      * Shipping method for this collection, if shipping is required
  115.      * @var IsotopeShipping
  116.      */
  117.     protected $objShipping = false;
  119.     /**
  120.      * Payment method for this collection, if payment is required
  121.      * @var IsotopePayment
  122.      */
  123.     protected $objPayment = false;
  126.     /**
  127.      * Constructor
  128.      *
  129.      * @param \Database\Result $objResult
  130.      */
  131.     public function __construct(\Database\Result $objResult = null)
  132.     {
  133.         parent::__construct($objResult);
  135.         $this->arrData['uniqid'] = $this->generateUniqueId();
  137.         // Do not use __destruct, because Database object might be destructed first
  138.         // see http://github.com/contao/core/issues/2236
  139.         if ('FE' === TL_MODE) {
  140.             register_shutdown_function(array($this, 'updateDatabase'), false);
  141.         }
  142.     }
  144.     /**
  145.      * Prevent cloning because we can't copy items etc.
  146.      *
  147.      * @throws \LogicException because ProductCollection cannot be cloned
  148.      */
  149.     /** @noinspection MagicMethodsValidityInspection */
  150.     public function __clone()
  151.     {
  152.         throw new \LogicException(
  153.             'Product collections can\'t be cloned, you should probably use ProductCollection::createFromCollection'
  154.         );
  155.     }
  157.     /**
  158.      * Shutdown function to update prices of items and collection
  159.      *
  160.      * @param boolean $blnCreate If true create Model even if not in registry or not saved at all
  161.      */
  162.     public function updateDatabase($blnCreate = true)
  163.     {
  164.         if (!$this->blnPreventSaving
  165.             && !$this->isLocked()
  166.             && (Registry::getInstance()->isRegistered($this) || $blnCreate)
  167.         ) {
  168.             foreach ($this->getItems() as $objItem) {
  169.                 if (!$objItem->hasProduct()) {
  170.                     continue;
  171.                 }
  173.                 $objItem->price          = $objItem->getPrice();
  174.                 $objItem->tax_free_price = $objItem->getTaxFreePrice();
  175.                 $objItem->save();
  176.             }
  178.             // First call to __set for tstamp will truncate the cache
  179.             $this->tstamp            = time();
  180.             $this->subtotal          = $this->getSubtotal();
  181.             $this->tax_free_subtotal = $this->getTaxFreeSubtotal();
  182.             $this->total             = $this->getTotal();
  183.             $this->tax_free_total    = $this->getTaxFreeTotal();
  184.             $this->currency          = (string) $this->getConfig()->currency;
  186.             $this->save();
  187.         }
  188.     }
  190.     /**
  191.      * Mark a field as modified
  192.      *
  193.      * @param string $strKey The field key
  194.      */
  195.     public function markModified($strKey)
  196.     {
  197.         if ('locked' === $strKey) {
  198.             throw new \InvalidArgumentException('Cannot change lock status of collection');
  199.         }
  201.         if ('document_number' === $strKey) {
  202.             throw new \InvalidArgumentException(
  203.                 'Cannot change document number of a collection, must be generated using generateDocumentNumber()'
  204.             );
  205.         }
  207.         $this->clearCache();
  209.         parent::markModified($strKey);
  210.     }
  212.     /**
  213.      * @inheritdoc
  214.      */
  215.     public function getId()
  216.     {
  217.         return (int) $this->id;
  218.     }
  220.     /**
  221.      * @inheritdoc
  222.      */
  223.     public function getUniqueId()
  224.     {
  225.         return $this->uniqid;
  226.     }
  228.     /**
  229.      * @inheritdoc
  230.      */
  231.     public function getMember()
  232.     {
  233.         if (0 === (int) $this->member) {
  234.             return null;
  235.         }
  237.         return MemberModel::findByPk($this->member);
  238.     }
  240.     /**
  241.      * @inheritdoc
  242.      */
  243.     public function getStoreId()
  244.     {
  245.         return (int) $this->store_id;
  246.     }
  248.     /**
  249.      * @inheritdoc
  250.      */
  251.     public function getConfig()
  252.     {
  253.         try {
  254.             return $this->getRelated('config_id');
  255.         } catch (\Exception $e) {
  256.             return null;
  257.         }
  258.     }
  260.     /**
  261.      * @inheritdoc
  262.      */
  263.     public function isLocked()
  264.     {
  265.         return null !== $this->locked;
  266.     }
  268.     /**
  269.      * @inheritdoc
  270.      */
  271.     public function getLockTime()
  272.     {
  273.         return $this->locked;
  274.     }
  277.     /**
  278.      * @inheritdoc
  279.      */
  280.     public function isEmpty()
  281.     {
  282.         return 0 === \count($this->getItems());
  283.     }
  285.     /**
  286.      * Return payment method for this collection
  287.      *
  288.      * @return IsotopePayment|null
  289.      */
  290.     public function getPaymentMethod()
  291.     {
  292.         if (false === $this->objPayment) {
  293.             try {
  294.                 $this->objPayment = $this->getRelated('payment_id');
  295.             } catch (\Exception $e) {
  296.                 $this->objPayment = null;
  297.             }
  298.         }
  300.         return $this->objPayment;
  301.     }
  303.     /**
  304.      * Set payment method for this collection
  305.      *
  306.      * @param IsotopePayment $objPayment
  307.      */
  308.     public function setPaymentMethod(IsotopePayment $objPayment = null)
  309.     {
  310.         $this->payment_id = (null === $objPayment ? 0 : $objPayment->getId());
  311.         $this->objPayment = $objPayment;
  312.     }
  314.     /**
  315.      * Return surcharge for current payment method
  316.      *
  317.      * @return ProductCollectionSurcharge|null
  318.      */
  319.     public function getPaymentSurcharge()
  320.     {
  321.         return $this->hasPayment() ? $this->getPaymentMethod()->getSurcharge($this) : null;
  322.     }
  324.     /**
  325.      * Return boolean whether collection has payment
  326.      *
  327.      * @return bool
  328.      */
  329.     public function hasPayment()
  330.     {
  331.         return null !== $this->getPaymentMethod();
  332.     }
  334.     /**
  335.      * Return boolean whether collection requires payment
  336.      *
  337.      * @return bool
  338.      */
  339.     public function requiresPayment()
  340.     {
  341.         return $this->getTotal() > 0;
  342.     }
  344.     /**
  345.      * Return shipping method for this collection
  346.      *
  347.      * @return IsotopeShipping|null
  348.      */
  349.     public function getShippingMethod()
  350.     {
  351.         if (false === $this->objShipping) {
  352.             try {
  353.                 $this->objShipping = $this->getRelated('shipping_id');
  354.             } catch (\Exception $e) {
  355.                 $this->objShipping = null;
  356.             }
  357.         }
  359.         return $this->objShipping;
  360.     }
  362.     /**
  363.      * Set shipping method for this collection
  364.      *
  365.      * @param IsotopeShipping $objShipping
  366.      */
  367.     public function setShippingMethod(IsotopeShipping $objShipping = null)
  368.     {
  369.         $this->shipping_id = (null === $objShipping ? 0 : $objShipping->getId());
  370.         $this->objShipping = $objShipping;
  371.     }
  373.     /**
  374.      * Return surcharge for current shipping method
  375.      *
  376.      * @return ProductCollectionSurcharge|null
  377.      */
  378.     public function getShippingSurcharge()
  379.     {
  380.         return $this->hasShipping() ? $this->getShippingMethod()->getSurcharge($this) : null;
  381.     }
  383.     /**
  384.      * Return boolean whether collection has shipping
  385.      *
  386.      * @return bool
  387.      */
  388.     public function hasShipping()
  389.     {
  390.         return null !== $this->getShippingMethod();
  391.     }
  393.     /**
  394.      * Return boolean whether collection requires shipping
  395.      *
  396.      * @return bool
  397.      */
  398.     public function requiresShipping()
  399.     {
  400.         if (!isset($this->arrCache['requiresShipping'])) {
  401.             $this->arrCache['requiresShipping'] = false;
  402.             $arrItems = $this->getItems();
  404.             foreach ($arrItems as $objItem) {
  405.                 if ($objItem->hasProduct() && !$objItem->getProduct()->isExemptFromShipping()) {
  406.                     $this->arrCache['requiresShipping'] = true;
  407.                     break;
  408.                 }
  409.             }
  410.         }
  412.         return $this->arrCache['requiresShipping'];
  413.     }
  415.     /**
  416.      * Get billing address for collection
  417.      *
  418.      * @return  \Isotope\Model\Address|null
  419.      */
  420.     public function getBillingAddress()
  421.     {
  422.         if (!$this->billing_address_id) {
  423.             return null;
  424.         }
  426.         return $this->getRelated('billing_address_id');
  427.     }
  429.     /**
  430.      * Set billing address for collection
  431.      *
  432.      * @param Address $objAddress
  433.      */
  434.     public function setBillingAddress(Address $objAddress = null)
  435.     {
  436.         if (null === $objAddress || $objAddress->id < 1) {
  437.             $this->billing_address_id = 0;
  438.         } else {
  439.             $this->billing_address_id = $objAddress->id;
  440.         }
  441.     }
  443.     /**
  444.      * Return boolean whether collection requires a shipping address
  445.      *
  446.      * @return bool
  447.      */
  448.     public function requiresShippingAddress()
  449.     {
  450.         if (!$this->requiresShipping()) {
  451.             return false;
  452.         }
  454.         if (!isset($this->arrCache['requiresShippingAddress'])) {
  455.             $this->arrCache['requiresShippingAddress'] = true;
  456.             $arrItems = $this->getItems();
  458.             foreach ($arrItems as $objItem) {
  459.                 $product = $objItem->getProduct();
  460.                 if ($product instanceof IsotopeProduct && \method_exists($product, 'isPickupOnly') && $product->isPickupOnly()) {
  461.                     $this->arrCache['requiresShippingAddress'] = false;
  462.                     break;
  463.                 }
  464.             }
  465.         }
  467.         return $this->arrCache['requiresShippingAddress'];
  468.     }
  470.     /**
  471.      * Get shipping address for collection
  472.      *
  473.      * @return  Address|null
  474.      */
  475.     public function getShippingAddress()
  476.     {
  477.         if (!$this->shipping_address_id || !$this->requiresShippingAddress()) {
  478.             return null;
  479.         }
  481.         return $this->getRelated('shipping_address_id');
  482.     }
  484.     /**
  485.      * Set shipping address for collection
  486.      *
  487.      * @param Address $objAddress
  488.      */
  489.     public function setShippingAddress(Address $objAddress = null)
  490.     {
  491.         if (null === $objAddress || $objAddress->id < 1) {
  492.             $this->shipping_address_id = 0;
  493.         } else {
  494.             $this->shipping_address_id = $objAddress->id;
  495.         }
  496.     }
  498.     /**
  499.      * Returns the generated document number or empty string if not available.
  500.      *
  501.      * @return string
  502.      */
  503.     public function getDocumentNumber()
  504.     {
  505.         return (string) $this->arrData['document_number'];
  506.     }
  508.     /**
  509.      * Return customer email address for the collection
  510.      *
  511.      * @return string
  512.      */
  513.     public function getEmailRecipient()
  514.     {
  515.         $strName            = '';
  516.         $strEmail           = '';
  517.         $objBillingAddress  = $this->getBillingAddress();
  518.         $objShippingAddress = $this->getShippingAddress();
  520.         if ($objBillingAddress->email != '') {
  521.             $strName  = $objBillingAddress->firstname . ' ' . $objBillingAddress->lastname;
  522.             $strEmail = $objBillingAddress->email;
  523.         } elseif ($objShippingAddress->email != '') {
  524.             $strName  = $objShippingAddress->firstname . ' ' . $objShippingAddress->lastname;
  525.             $strEmail = $objShippingAddress->email;
  526.         } elseif ($this->member > 0
  527.             && ($objMember = MemberModel::findByPk($this->member)) !== null
  528.             && $objMember->email != ''
  529.         ) {
  530.             $strName  = $objMember->firstname . ' ' . $objMember->lastname;
  531.             $strEmail = $objMember->email;
  532.         }
  534.         if (trim($strName) != '') {
  535.             // Romanize friendly name to prevent email issues
  536.             $strName = html_entity_decode($strName, ENT_QUOTES, $GLOBALS['TL_CONFIG']['characterSet']);
  537.             $strName = StringUtil::stripInsertTags($strName);
  538.             $strName = utf8_romanize($strName);
  539.             $strName = preg_replace('/[^A-Za-z0-9.!#$%&\'*+-\/=?^_ `{|}~]+/i', '_', $strName);
  541.             $strEmail = sprintf('"%s" <%s>', $strName, $strEmail);
  542.         }
  544.         // !HOOK: determine email recipient for collection
  545.         if (isset($GLOBALS['ISO_HOOKS']['emailRecipientForCollection'])
  546.             && \is_array($GLOBALS['ISO_HOOKS']['emailRecipientForCollection'])
  547.         ) {
  548.             foreach ($GLOBALS['ISO_HOOKS']['emailRecipientForCollection'] as $callback) {
  549.                 $strEmail = System::importStatic($callback[0])->{$callback[1]}($strEmail, $this);
  550.             }
  551.         }
  553.         return $strEmail;
  554.     }
  556.     /**
  557.      * Return number of items in the collection
  558.      *
  559.      * @return int
  560.      */
  561.     public function countItems()
  562.     {
  563.         if (!isset($this->arrCache['countItems'])) {
  564.             $this->arrCache['countItems'] = ProductCollectionItem::countBy('pid', (int) $this->id);
  565.         }
  567.         return $this->arrCache['countItems'];
  568.     }
  570.     /**
  571.      * Return summary of item quantity in collection
  572.      *
  573.      * @return int
  574.      */
  575.     public function sumItemsQuantity()
  576.     {
  577.         if (!isset($this->arrCache['sumItemsQuantity'])) {
  578.             $this->arrCache['sumItemsQuantity'] = ProductCollectionItem::sumBy('quantity', 'pid', (int) $this->id);
  579.         }
  581.         return $this->arrCache['sumItemsQuantity'];
  582.     }
  584.     /**
  585.      * Load settings from database field
  586.      *
  587.      * @param array $arrData
  588.      *
  589.      * @return $this
  590.      */
  591.     public function setRow(array $arrData)
  592.     {
  593.         parent::setRow($arrData);
  595.         // Merge settings into arrData, save() will move the values back
  596.         $this->arrData = array_merge(StringUtil::deserialize($arrData['settings'] ?? [], true), $this->arrData);
  598.         return $this;
  599.     }
  601.     /**
  602.      * Save all non-database fields in the settings array
  603.      *
  604.      * @return $this
  605.      */
  606.     public function save()
  607.     {
  608.         // The instance cannot be saved
  609.         if ($this->blnPreventSaving) {
  610.             throw new \LogicException('The model instance has been detached and cannot be saved');
  611.         }
  613.         // !HOOK: additional functionality when saving a collection
  614.         if (isset($GLOBALS['ISO_HOOKS']['saveCollection']) && \is_array($GLOBALS['ISO_HOOKS']['saveCollection'])) {
  615.             foreach ($GLOBALS['ISO_HOOKS']['saveCollection'] as $callback) {
  616.                 System::importStatic($callback[0])->{$callback[1]}($this);
  617.             }
  618.         }
  620.         $arrDbFields = Database::getInstance()->getFieldNames(static::$strTable);
  621.         $arrModified = array_diff_key($this->arrModified, array_flip($arrDbFields));
  623.         if (!empty($arrModified)) {
  624.             $arrSettings = StringUtil::deserialize($this->settings, true);
  625.             $arrSettings = array_merge($arrSettings, array_intersect_key($this->arrData, $arrModified));
  627.             $this->settings = serialize($arrSettings);
  628.         }
  630.         return parent::save();
  631.     }
  633.     /**
  634.      * Also delete child table records when dropping this collection
  635.      *
  636.      * @param bool $blnForce Force to delete the collection even if it's locked
  637.      *
  638.      * @return int Number of rows affected
  639.      *
  640.      * @throws \BadMethodCallException if the product collection is locked.
  641.      */
  642.     public function delete($blnForce = false)
  643.     {
  644.         if (!$blnForce) {
  645.             $this->ensureNotLocked();
  647.             // !HOOK: additional functionality when deleting a collection
  648.             if (isset($GLOBALS['ISO_HOOKS']['deleteCollection'])
  649.                 && \is_array($GLOBALS['ISO_HOOKS']['deleteCollection'])
  650.             ) {
  651.                 foreach ($GLOBALS['ISO_HOOKS']['deleteCollection'] as $callback) {
  652.                     $blnRemove = System::importStatic($callback[0])->{$callback[1]}($this);
  654.                     if ($blnRemove === false) {
  655.                         return 0;
  656.                     }
  657.                 }
  658.             }
  659.         }
  661.         $intPid          = $this->id;
  662.         $intAffectedRows = parent::delete();
  664.         if ($intAffectedRows > 0 && $intPid > 0) {
  665.             Database::getInstance()->query("
  666.                 DELETE FROM tl_iso_product_collection_download
  667.                 WHERE pid IN (SELECT id FROM tl_iso_product_collection_item WHERE pid=$intPid)
  668.             ");
  669.             Database::getInstance()->query(
  670.                 "DELETE FROM tl_iso_product_collection_item WHERE pid=$intPid"
  671.             );
  672.             Database::getInstance()->query(
  673.                 "DELETE FROM tl_iso_product_collection_surcharge WHERE pid=$intPid"
  674.             );
  675.             Database::getInstance()->query(
  676.                 "DELETE FROM tl_iso_address WHERE ptable='" . static::$strTable . "' AND pid=$intPid"
  677.             );
  678.         }
  680.         $this->arrCache      = array();
  681.         $this->arrItems      = null;
  682.         $this->arrSurcharges = null;
  684.         // !HOOK: additional functionality when deleting a collection
  685.         if (isset($GLOBALS['ISO_HOOKS']['postDeleteCollection'])
  686.             && \is_array($GLOBALS['ISO_HOOKS']['postDeleteCollection'])
  687.         ) {
  688.             foreach ($GLOBALS['ISO_HOOKS']['postDeleteCollection'] as $callback) {
  689.                 System::importStatic($callback[0])->{$callback[1]}($this, $intPid);
  690.             }
  691.         }
  693.         return $intAffectedRows;
  694.     }
  696.     /**
  697.      * Delete all products in the collection
  698.      *
  699.      * @throws \BadMethodCallException if the product collection is locked.
  700.      */
  701.     public function purge()
  702.     {
  703.         $this->ensureNotLocked();
  705.         foreach ($this->getItems() as $objItem) {
  706.             $this->deleteItem($objItem);
  707.         }
  709.         foreach ($this->getSurcharges() as $objSurcharge) {
  710.             if ($objSurcharge->id) {
  711.                 $objSurcharge->delete();
  712.             }
  713.         }
  715.         $this->clearCache();
  716.     }
  718.     /**
  719.      * Lock collection from begin modified
  720.      *
  721.      * @throws \BadMethodCallException if the product collection is locked.
  722.      */
  723.     public function lock()
  724.     {
  725.         $this->ensureNotLocked();
  727.         global $objPage;
  728.         $time = time();
  730.         $this->pageId = (int) $objPage->id;
  731.         $this->language = (string) $GLOBALS['TL_LANGUAGE'];
  733.         $this->createPrivateAddresses();
  734.         $this->updateDatabase();
  736.         // Add surcharges to the collection
  737.         $sorting = 128;
  738.         foreach ($this->getSurcharges() as $objSurcharge) {
  739.             $objSurcharge->pid     = $this->id;
  740.             $objSurcharge->tstamp  = $time;
  741.             $objSurcharge->sorting = $sorting;
  742.             $objSurcharge->save();
  744.             $sorting += 128;
  745.         }
  747.         // Add downloads from products to the collection
  748.         foreach (ProductCollectionDownload::createForProductsInCollection($this) as $objDownload) {
  749.             $objDownload->save();
  750.         }
  752.         // Can't use model, it would not save as soon as it's locked
  753.         Database::getInstance()->query(
  754.             "UPDATE tl_iso_product_collection SET locked=$time WHERE id=" . $this->id
  755.         );
  756.         $this->arrData['locked'] = $time;
  758.         // !HOOK: pre-process checkout
  759.         if (isset($GLOBALS['ISO_HOOKS']['collectionLocked']) && \is_array($GLOBALS['ISO_HOOKS']['collectionLocked'])) {
  760.             foreach ($GLOBALS['ISO_HOOKS']['collectionLocked'] as $callback) {
  761.                 System::importStatic($callback[0])->{$callback[1]}($this);
  762.             }
  763.         }
  765.         $this->clearCache();
  766.     }
  768.     /**
  769.      * Sum total price of all items in the collection
  770.      *
  771.      * @return float
  772.      */
  773.     public function getSubtotal()
  774.     {
  775.         if ($this->isLocked()) {
  776.             return $this->subtotal;
  777.         }
  779.         if (!isset($this->arrCache['subtotal'])) {
  780.             $fltAmount = 0;
  781.             $arrItems  = $this->getItems();
  783.             foreach ($arrItems as $objItem) {
  784.                 $varPrice = $objItem->getTotalPrice();
  786.                 if ($varPrice !== null) {
  787.                     $fltAmount += $varPrice;
  788.                 }
  789.             }
  791.             $this->arrCache['subtotal'] = $fltAmount;
  792.         }
  794.         return $this->arrCache['subtotal'];
  795.     }
  797.     /**
  798.      * Sum total tax free price of all items in the collection
  799.      *
  800.      * @return float
  801.      */
  802.     public function getTaxFreeSubtotal()
  803.     {
  804.         if ($this->isLocked()) {
  805.             return $this->tax_free_subtotal;
  806.         }
  808.         if (!isset($this->arrCache['taxFreeSubtotal'])) {
  809.             $fltAmount = 0;
  810.             $arrItems  = $this->getItems();
  812.             foreach ($arrItems as $objItem) {
  813.                 $varPrice = $objItem->getTaxFreeTotalPrice();
  815.                 if ($varPrice !== null) {
  816.                     $fltAmount += $varPrice;
  817.                 }
  818.             }
  820.             $this->arrCache['taxFreeSubtotal'] = $fltAmount;
  821.         }
  823.         return $this->arrCache['taxFreeSubtotal'];
  824.     }
  826.     /**
  827.      * Sum total price of items and surcharges
  828.      *
  829.      * @return float
  830.      */
  831.     public function getTotal()
  832.     {
  833.         if ($this->isLocked()) {
  834.             return $this->total;
  835.         }
  837.         if (!isset($this->arrCache['total'])) {
  838.             $fltAmount     = $this->getSubtotal();
  839.             $arrSurcharges = $this->getSurcharges();
  841.             foreach ($arrSurcharges as $objSurcharge) {
  842.                 if ($objSurcharge->addToTotal) {
  843.                     $fltAmount += $objSurcharge->total_price;
  844.                 }
  845.             }
  847.             $this->arrCache['total'] = $fltAmount > 0 ? $fltAmount : 0;
  848.         }
  850.         return $this->arrCache['total'];
  851.     }
  853.     /**
  854.      * Sum tax free total of items and surcharges
  855.      *
  856.      * @return float
  857.      */
  858.     public function getTaxFreeTotal()
  859.     {
  860.         if ($this->isLocked()) {
  861.             return $this->tax_free_total;
  862.         }
  864.         if (!isset($this->arrCache['taxFreeTotal'])) {
  865.             $arrSurcharges = $this->getSurcharges();
  867.             if (Config::PRICE_DISPLAY_GROSS === $this->getConfig()->priceDisplay) {
  868.                 $fltAmount = $this->getTotal();
  870.                 foreach ($arrSurcharges as $objSurcharge) {
  871.                     if ($objSurcharge instanceof Tax) {
  872.                         $fltAmount -= $objSurcharge->total_price;
  873.                     }
  874.                 }
  875.             } else {
  876.                 $fltAmount = $this->getTaxFreeSubtotal();
  878.                 foreach ($arrSurcharges as $objSurcharge) {
  879.                     if ($objSurcharge->addToTotal) {
  880.                         $fltAmount += $objSurcharge->tax_free_total_price;
  881.                     }
  882.                 }
  883.             }
  885.             $this->arrCache['taxFreeTotal'] = $fltAmount > 0 ? Isotope::roundPrice($fltAmount) : 0;
  886.         }
  888.         return $this->arrCache['taxFreeTotal'];
  889.     }
  891.     /**
  892.      * @inheritdoc
  893.      */
  894.     public function getCurrency()
  895.     {
  896.         return $this->currency;
  897.     }
  899.     /**
  900.      * Return the item with the latest timestamp (e.g. the latest added item)
  901.      *
  902.      * @return ProductCollectionItem|null
  903.      */
  904.     public function getLatestItem()
  905.     {
  906.         if (!isset($this->arrCache['latestItem'])) {
  907.             $latest   = 0;
  908.             $arrItems = $this->getItems();
  910.             foreach ($arrItems as $objItem) {
  911.                 if ($objItem->tstamp > $latest) {
  912.                     $this->arrCache['latestItem'] = $objItem;
  913.                     $latest                       = $objItem->tstamp;
  914.                 }
  915.             }
  916.         }
  918.         return $this->arrCache['latestItem'];
  919.     }
  921.     /**
  922.      * Return timestamp when this collection was created
  923.      * This is relevant for price calculation
  924.      *
  925.      * @return int
  926.      */
  927.     public function getLastModification()
  928.     {
  929.         if ($this->isLocked()) {
  930.             return $this->locked;
  931.         }
  933.         return $this->tstamp ? : time();
  934.     }
  936.     /**
  937.      * Return all items in the collection
  938.      *
  939.      * @param callable $varCallable
  940.      * @param bool     $blnNoCache
  941.      *
  942.      * @return ProductCollectionItem[]
  943.      */
  944.     public function getItems($varCallable = null, $blnNoCache = false)
  945.     {
  946.         if (null === $this->arrItems || $blnNoCache) {
  947.             $this->arrItems = array();
  949.             if (($objItems = ProductCollectionItem::findBy('pid', $this->id)) !== null) {
  950.                 /** @var ProductCollectionItem $objItem */
  951.                 foreach ($objItems as $objItem) {
  952.                     if ($this->isLocked()) {
  953.                         $objItem->lock();
  954.                     }
  956.                     // Add error message for items no longer available
  957.                     if (!$objItem->isAvailable() && !$objItem->hasErrors()) {
  958.                         $objItem->addError($GLOBALS['TL_LANG']['ERR']['collectionItemNotAvailable']);
  959.                     }
  961.                     $this->arrItems[$objItem->id] = $objItem;
  962.                 }
  963.             }
  964.         }
  966.         if ($varCallable === null) {
  967.             return $this->arrItems;
  968.         }
  970.         // not allowed to chance items
  971.         $arrItems = $this->arrItems;
  973.         return \call_user_func($varCallable, $arrItems);
  974.     }
  976.     /**
  977.      * Search item for a specific product
  978.      *
  979.      * @param IsotopeProduct $objProduct
  980.      *
  981.      * @return ProductCollectionItem|null
  982.      */
  983.     public function getItemForProduct(IsotopeProduct $objProduct)
  984.     {
  985.         $strClass = array_search(\get_class($objProduct), Product::getModelTypes(), true);
  987.         $objItem = ProductCollectionItem::findOneBy(
  988.             array('pid=?', 'type=?', 'product_id=?', 'configuration=?'),
  989.             array($this->id, $strClass, $objProduct->getId(), serialize($objProduct->getOptions()))
  990.         );
  992.         return $objItem;
  993.     }
  995.     /**
  996.      * Gets the product collection with given ID if it belongs to this collection.
  997.      *
  998.      * @param int $id
  999.      *
  1000.      * @return ProductCollectionItem|null
  1001.      */
  1002.     public function getItemById($id)
  1003.     {
  1004.         $items = $this->getItems();
  1006.         if (!isset($items[$id])) {
  1007.             return null;
  1008.         }
  1010.         return $items[$id];
  1011.     }
  1013.     /**
  1014.      * Check if a given product is already in the collection
  1015.      *
  1016.      * @param IsotopeProduct $objProduct
  1017.      * @param bool           $blnIdentical
  1018.      *
  1019.      * @return bool
  1020.      */
  1021.     public function hasProduct(IsotopeProduct $objProduct, $blnIdentical = true)
  1022.     {
  1023.         if (true === $blnIdentical) {
  1024.             return null !== $this->getItemForProduct($objProduct);
  1025.         }
  1027.         $intId = $objProduct->getProductId();
  1029.         foreach ($this->getItems() as $objItem) {
  1030.             if ($objItem->hasProduct()
  1031.                 && ($objItem->getProduct()->getId() == $intId || $objItem->getProduct()->getProductId() == $intId)
  1032.             ) {
  1033.                 return true;
  1034.             }
  1035.         }
  1037.         return false;
  1038.     }
  1040.     /**
  1041.      * Add a product to the collection
  1042.      *
  1043.      * @param IsotopeProduct $objProduct
  1044.      * @param int            $intQuantity
  1045.      * @param array          $arrConfig
  1046.      *
  1047.      * @return ProductCollectionItem|false
  1048.      */
  1049.     public function addProduct(IsotopeProduct $objProduct, $intQuantity, array $arrConfig = array())
  1050.     {
  1051.         // !HOOK: additional functionality when adding product to collection
  1052.         if (isset($GLOBALS['ISO_HOOKS']['addProductToCollection'])
  1053.             && \is_array($GLOBALS['ISO_HOOKS']['addProductToCollection'])
  1054.         ) {
  1055.             foreach ($GLOBALS['ISO_HOOKS']['addProductToCollection'] as $callback) {
  1056.                 $intQuantity = System::importStatic($callback[0])->{$callback[1]}($objProduct, $intQuantity, $this, $arrConfig);
  1057.             }
  1058.         }
  1060.         if ($intQuantity == 0) {
  1061.             return false;
  1062.         }
  1064.         $time         = time();
  1065.         $this->tstamp = $time;
  1067.         // Make sure collection is in DB before adding product
  1068.         if (!Registry::getInstance()->isRegistered($this)) {
  1069.             $this->save();
  1070.         }
  1072.         // Remove uploaded files from session so they are not added to the next product (see #646)
  1073.         unset($_SESSION['FILES']);
  1075.         $objItem            = $this->getItemForProduct($objProduct);
  1076.         $intMinimumQuantity = $objProduct->getMinimumQuantity();
  1078.         if (null !== $objItem) {
  1079.             if (($objItem->quantity + $intQuantity) < $intMinimumQuantity) {
  1080.                 Message::addInfo(sprintf(
  1081.                     $GLOBALS['TL_LANG']['ERR']['productMinimumQuantity'],
  1082.                     $objProduct->getName(),
  1083.                     $intMinimumQuantity
  1084.                 ));
  1085.                 $intQuantity            = $intMinimumQuantity - $objItem->quantity;
  1086.             }
  1088.             $objItem->increaseQuantityBy($intQuantity);
  1089.         } else {
  1090.             if ($intQuantity < $intMinimumQuantity) {
  1091.                 Message::addInfo(sprintf(
  1092.                     $GLOBALS['TL_LANG']['ERR']['productMinimumQuantity'],
  1093.                     $objProduct->getName(),
  1094.                     $intMinimumQuantity
  1095.                 ));
  1096.                 $intQuantity            = $intMinimumQuantity;
  1097.             }
  1099.             $objItem           = new ProductCollectionItem();
  1100.             $objItem->pid      = $this->id;
  1101.             $objItem->jumpTo   = isset($arrConfig['jumpTo']) ? (int) $arrConfig['jumpTo']->id : 0;
  1103.             $this->setProductForItem($objProduct, $objItem, $intQuantity);
  1104.             $objItem->save();
  1106.             // Add the new item to our cache
  1107.             $this->arrItems[$objItem->id] = $objItem;
  1108.         }
  1110.         // !HOOK: additional functionality when adding product to collection
  1111.         if (isset($GLOBALS['ISO_HOOKS']['postAddProductToCollection'])
  1112.             && \is_array($GLOBALS['ISO_HOOKS']['postAddProductToCollection'])
  1113.         ) {
  1114.             foreach ($GLOBALS['ISO_HOOKS']['postAddProductToCollection'] as $callback) {
  1115.                 System::importStatic($callback[0])->{$callback[1]}($objItem, $intQuantity, $this, $arrConfig);
  1116.             }
  1117.         }
  1119.         return $objItem;
  1120.     }
  1122.     /**
  1123.      * Update product details for a collection item.
  1124.      *
  1125.      * @param IsotopeProduct        $objProduct
  1126.      * @param ProductCollectionItem $objItem
  1127.      *
  1128.      * @return bool
  1129.      */
  1130.     public function updateProduct(IsotopeProduct $objProduct, ProductCollectionItem $objItem)
  1131.     {
  1132.         if ($objItem->pid != $this->id) {
  1133.             throw new \InvalidArgumentException('Item does not belong to this collection');
  1134.         }
  1136.         // !HOOK: additional functionality when updating product in collection
  1137.         if (isset($GLOBALS['ISO_HOOKS']['updateProductInCollection'])
  1138.             && \is_array($GLOBALS['ISO_HOOKS']['updateProductInCollection'])
  1139.         ) {
  1140.             foreach ($GLOBALS['ISO_HOOKS']['updateProductInCollection'] as $callback) {
  1141.                 if (false === System::importStatic($callback[0])->{$callback[1]}($objProduct, $objItem, $this)) {
  1142.                     return false;
  1143.                 }
  1144.             }
  1145.         }
  1147.         $this->setProductForItem($objProduct, $objItem, $objItem->quantity);
  1148.         $objItem->save();
  1150.         // !HOOK: additional functionality when adding product to collection
  1151.         if (isset($GLOBALS['ISO_HOOKS']['postUpdateProductInCollection'])
  1152.             && \is_array($GLOBALS['ISO_HOOKS']['postUpdateProductInCollection'])
  1153.         ) {
  1154.             foreach ($GLOBALS['ISO_HOOKS']['postUpdateProductInCollection'] as $callback) {
  1155.                 System::importStatic($callback[0])->{$callback[1]}($objProduct, $objItem, $this);
  1156.             }
  1157.         }
  1159.         return true;
  1160.     }
  1162.     /**
  1163.      * Update a product collection item
  1164.      *
  1165.      * @param ProductCollectionItem $objItem The product object
  1166.      * @param array                 $arrSet  The property(ies) to adjust
  1167.      *
  1168.      * @return bool
  1169.      */
  1170.     public function updateItem(ProductCollectionItem $objItem, $arrSet)
  1171.     {
  1172.         return $this->updateItemById($objItem->id, $arrSet);
  1173.     }
  1175.     /**
  1176.      * Update product collection item with given ID
  1177.      *
  1178.      * @param int   $intId
  1179.      * @param array $arrSet
  1180.      *
  1181.      * @return bool
  1182.      */
  1183.     public function updateItemById($intId, $arrSet)
  1184.     {
  1185.         $this->ensureNotLocked();
  1187.         $arrItems = $this->getItems();
  1189.         if (!isset($arrItems[$intId])) {
  1190.             return false;
  1191.         }
  1193.         /** @var ProductCollectionItem $objItem */
  1194.         $objItem = $arrItems[$intId];
  1196.         // !HOOK: additional functionality when updating a product in the collection
  1197.         if (isset($GLOBALS['ISO_HOOKS']['updateItemInCollection'])
  1198.             && \is_array($GLOBALS['ISO_HOOKS']['updateItemInCollection'])
  1199.         ) {
  1200.             foreach ($GLOBALS['ISO_HOOKS']['updateItemInCollection'] as $callback) {
  1201.                 $arrSet = System::importStatic($callback[0])->{$callback[1]}($objItem, $arrSet, $this);
  1203.                 if (!\is_array($arrSet) || 0 === \count($arrSet)) {
  1204.                     return false;
  1205.                 }
  1206.             }
  1207.         }
  1209.         // Quantity set to 0, delete item
  1210.         if (isset($arrSet['quantity']) && $arrSet['quantity'] == 0) {
  1211.             return $this->deleteItemById($intId);
  1212.         }
  1214.         if (isset($arrSet['quantity']) && $objItem->hasProduct()) {
  1216.             // Set product quantity so we can determine the correct minimum price
  1217.             $objProduct         = $objItem->getProduct();
  1218.             $intMinimumQuantity = $objProduct->getMinimumQuantity();
  1220.             if ($arrSet['quantity'] < $intMinimumQuantity) {
  1221.                 Message::addInfo(sprintf(
  1222.                     $GLOBALS['TL_LANG']['ERR']['productMinimumQuantity'],
  1223.                     $objProduct->getName(),
  1224.                     $intMinimumQuantity
  1225.                 ));
  1226.                 $arrSet['quantity']     = $intMinimumQuantity;
  1227.             }
  1228.         }
  1230.         $arrSet['tstamp'] = time();
  1232.         foreach ($arrSet as $k => $v) {
  1233.             $objItem->$k = $v;
  1234.         }
  1236.         $objItem->save();
  1237.         $this->tstamp = time();
  1239.         // !HOOK: additional functionality when adding product to collection
  1240.         if (isset($GLOBALS['ISO_HOOKS']['postUpdateItemInCollection'])
  1241.             && \is_array($GLOBALS['ISO_HOOKS']['postUpdateItemInCollection'])
  1242.         ) {
  1243.             foreach ($GLOBALS['ISO_HOOKS']['postUpdateItemInCollection'] as $callback) {
  1244.                 System::importStatic($callback[0])->{$callback[1]}($objItem, $arrSet['quantity'], $this);
  1245.             }
  1246.         }
  1248.         return true;
  1249.     }
  1251.     /**
  1252.      * Remove item from collection
  1253.      *
  1254.      * @param ProductCollectionItem $objItem
  1255.      *
  1256.      * @return bool
  1257.      */
  1258.     public function deleteItem(ProductCollectionItem $objItem)
  1259.     {
  1260.         return $this->deleteItemById($objItem->id);
  1261.     }
  1263.     /**
  1264.      * Remove item with given ID from collection
  1265.      *
  1266.      * @param int $intId
  1267.      *
  1268.      * @return bool
  1269.      *
  1270.      * @throws \BadMethodCallException if the product collection is locked.
  1271.      */
  1272.     public function deleteItemById($intId)
  1273.     {
  1274.         $this->ensureNotLocked();
  1276.         $arrItems = $this->getItems();
  1278.         if (!isset($arrItems[$intId])) {
  1279.             return false;
  1280.         }
  1282.         $objItem = $arrItems[$intId];
  1284.         // !HOOK: additional functionality when a product is removed from the collection
  1285.         if (isset($GLOBALS['ISO_HOOKS']['deleteItemFromCollection'])
  1286.             && \is_array($GLOBALS['ISO_HOOKS']['deleteItemFromCollection'])
  1287.         ) {
  1288.             foreach ($GLOBALS['ISO_HOOKS']['deleteItemFromCollection'] as $callback) {
  1289.                 $blnRemove = System::importStatic($callback[0])->{$callback[1]}($objItem, $this);
  1291.                 if ($blnRemove === false) {
  1292.                     return false;
  1293.                 }
  1294.             }
  1295.         }
  1297.         $objItem->delete();
  1299.         unset($this->arrItems[$intId]);
  1301.         $this->tstamp = time();
  1303.         // !HOOK: additional functionality when adding product to collection
  1304.         if (isset($GLOBALS['ISO_HOOKS']['postDeleteItemFromCollection'])
  1305.             && \is_array($GLOBALS['ISO_HOOKS']['postDeleteItemFromCollection'])
  1306.         ) {
  1307.             foreach ($GLOBALS['ISO_HOOKS']['postDeleteItemFromCollection'] as $callback) {
  1308.                 System::importStatic($callback[0])->{$callback[1]}($objItem, $this);
  1309.             }
  1310.         }
  1312.         return true;
  1313.     }
  1315.     /**
  1316.      * Find surcharges for the current collection
  1317.      *
  1318.      * @return ProductCollectionSurcharge[]
  1319.      */
  1320.     public function getSurcharges()
  1321.     {
  1322.         if (null === $this->arrSurcharges) {
  1323.             if ($this->isLocked()) {
  1324.                 $this->arrSurcharges = [];
  1326.                 if (($objSurcharges = ProductCollectionSurcharge::findBy('pid', $this->id)) !== null) {
  1327.                     $this->arrSurcharges = $objSurcharges->getModels();
  1328.                 }
  1329.             } else {
  1330.                 $this->arrSurcharges = ProductCollectionSurcharge::findForCollection($this);
  1331.             }
  1332.         }
  1334.         return $this->arrSurcharges;
  1335.     }
  1337.     /**
  1338.      * Copy product collection items from another collection to this one (e.g. Cart to Order)
  1339.      *
  1340.      * @param IsotopeProductCollection $objSource
  1341.      *
  1342.      * @return int[]
  1343.      *
  1344.      * @throws \BadMethodCallException if the product collection is locked.
  1345.      */
  1346.     public function copyItemsFrom(IsotopeProductCollection $objSource)
  1347.     {
  1348.         $this->ensureNotLocked();
  1350.         $this->updateDatabase();
  1352.         // Make sure database table has the latest prices
  1353.         $objSource->updateDatabase();
  1355.         $time        = time();
  1356.         $arrIds      = [];
  1357.         $arrOldItems = $objSource->getItems();
  1359.         foreach ($arrOldItems as $objOldItem) {
  1361.             // !HOOK: additional functionality when copying product to collection
  1362.             if (isset($GLOBALS['ISO_HOOKS']['copyCollectionItem'])
  1363.                 && \is_array($GLOBALS['ISO_HOOKS']['copyCollectionItem'])
  1364.             ) {
  1365.                 foreach ($GLOBALS['ISO_HOOKS']['copyCollectionItem'] as $callback) {
  1366.                     if (System::importStatic($callback[0])->{$callback[1]}($objOldItem, $objSource, $this) === false) {
  1367.                         continue;
  1368.                     }
  1369.                 }
  1370.             }
  1372.             if ($objOldItem->hasProduct() && $this->hasProduct($objOldItem->getProduct())) {
  1374.                 $objNewItem = $this->getItemForProduct($objOldItem->getProduct());
  1375.                 $objNewItem->increaseQuantityBy($objOldItem->quantity);
  1377.             } else {
  1379.                 $objNewItem         = clone $objOldItem;
  1380.                 $objNewItem->pid    = $this->id;
  1381.                 $objNewItem->tstamp = $time;
  1382.                 $objNewItem->save();
  1383.             }
  1385.             $arrIds[$objOldItem->id] = $objNewItem->id;
  1386.         }
  1388.         if (\count($arrIds) > 0) {
  1389.             $this->tstamp = $time;
  1390.         }
  1392.         // !HOOK: additional functionality when adding product to collection
  1393.         if (isset($GLOBALS['ISO_HOOKS']['copiedCollectionItems'])
  1394.             && \is_array($GLOBALS['ISO_HOOKS']['copiedCollectionItems'])
  1395.         ) {
  1396.             foreach ($GLOBALS['ISO_HOOKS']['copiedCollectionItems'] as $callback) {
  1397.                 System::importStatic($callback[0])->{$callback[1]}($objSource, $this, $arrIds);
  1398.             }
  1399.         }
  1401.         $this->clearCache();
  1403.         return $arrIds;
  1404.     }
  1406.     /**
  1407.      * Copy product collection surcharges from another collection to this one (e.g. Cart to Order)
  1408.      *
  1409.      * @param IsotopeProductCollection $objSource
  1410.      * @param array                    $arrItemMap
  1411.      *
  1412.      * @return int[]
  1413.      *
  1414.      * @deprecated Deprecated since version 2.2, to be removed in 3.0.
  1415.      *             Surcharges are calculated on the fly, so it does not make sense to copy them from another one.
  1416.      *
  1417.      * @throws \BadMethodCallException if the product collection is locked.
  1418.      */
  1419.     public function copySurchargesFrom(IsotopeProductCollection $objSource, array $arrItemMap = array())
  1420.     {
  1421.         $this->ensureNotLocked();
  1423.         $arrIds  = array();
  1424.         $time    = time();
  1425.         $sorting = 128;
  1427.         foreach ($objSource->getSurcharges() as $objSourceSurcharge) {
  1428.             $objSurcharge          = clone $objSourceSurcharge;
  1429.             $objSurcharge->pid     = $this->id;
  1430.             $objSurcharge->tstamp  = $time;
  1431.             $objSurcharge->sorting = $sorting;
  1433.             // Convert surcharge amount for individual product IDs
  1434.             $objSurcharge->convertCollectionItemIds($arrItemMap);
  1436.             $objSurcharge->save();
  1438.             $arrIds[$sorting] = $objSurcharge->id;
  1440.             $sorting += 128;
  1441.         }
  1443.         // Empty cache
  1444.         $this->arrSurcharges = null;
  1445.         $this->arrCache = null;
  1447.         return $arrIds;
  1448.     }
  1450.     /**
  1451.      * @inheritdoc
  1452.      */
  1453.     public function addToScale(Scale $objScale = null)
  1454.     {
  1455.         if (null === $objScale) {
  1456.             $objScale = new Scale();
  1457.         }
  1459.         foreach ($this->getItems() as $objItem) {
  1460.             if (!$objItem->hasProduct()) {
  1461.                 continue;
  1462.             }
  1464.             $objProduct = $objItem->getProduct();
  1466.             if ($objProduct instanceof WeightAggregate) {
  1467.                 $objWeight = $objProduct->getWeight();
  1469.                 if (null !== $objWeight) {
  1470.                     for ($i = 0; $i < $objItem->quantity; $i++) {
  1471.                         $objScale->add($objWeight);
  1472.                     }
  1473.                 }
  1475.             } elseif ($objProduct instanceof Weighable) {
  1476.                 for ($i = 0; $i < $objItem->quantity; $i++) {
  1477.                     $objScale->add($objProduct);
  1478.                 }
  1479.             }
  1480.         }
  1482.         return $objScale;
  1483.     }
  1485.     /**
  1486.      * @inheritdoc
  1487.      */
  1488.     public function addToTemplate(Template $objTemplate, array $arrConfig = [])
  1489.     {
  1490.         $arrGalleries = array();
  1491.         $objConfig    = $this->getRelated('config_id') ?: Isotope::getConfig();
  1492.         $arrItems     = $this->addItemsToTemplate($objTemplate, $arrConfig['sorting']);
  1494.         $objTemplate->id                = $this->id;
  1495.         $objTemplate->collection        = $this;
  1496.         $objTemplate->config            = $objConfig;
  1497.         $objTemplate->surcharges        = Frontend::formatSurcharges($this->getSurcharges(), $objConfig->currency);
  1498.         $objTemplate->subtotal          = Isotope::formatPriceWithCurrency($this->getSubtotal(), true, $objConfig->currency);
  1499.         $objTemplate->total             = Isotope::formatPriceWithCurrency($this->getTotal(), true, $objConfig->currency);
  1500.         $objTemplate->tax_free_subtotal = Isotope::formatPriceWithCurrency($this->getTaxFreeSubtotal(), true, $objConfig->currency);
  1501.         $objTemplate->tax_free_total    = Isotope::formatPriceWithCurrency($this->getTaxFreeTotal(), true, $objConfig->currency);
  1503.         $objTemplate->hasAttribute = function ($strAttribute, ProductCollectionItem $objItem) {
  1504.             if (!$objItem->hasProduct()) {
  1505.                 return false;
  1506.             }
  1508.             $objProduct = $objItem->getProduct();
  1510.             return \in_array($strAttribute, $objProduct->getAttributes(), true)
  1511.                 || \in_array($strAttribute, $objProduct->getVariantAttributes(), true);
  1512.         };
  1514.         $objTemplate->generateAttribute = function (
  1515.             $strAttribute,
  1516.             ProductCollectionItem $objItem,
  1517.             array $arrOptions = array()
  1518.         ) {
  1519.             if (!$objItem->hasProduct()) {
  1520.                 return '';
  1521.             }
  1523.             $objAttribute = $GLOBALS['TL_DCA']['tl_iso_product']['attributes'][$strAttribute];
  1525.             if (!($objAttribute instanceof IsotopeAttribute)) {
  1526.                 throw new \InvalidArgumentException($strAttribute . ' is not a valid attribute');
  1527.             }
  1529.             return $objAttribute->generate($objItem->getProduct(), $arrOptions);
  1530.         };
  1532.         $objTemplate->getGallery = function (
  1533.             $strAttribute,
  1534.             ProductCollectionItem $objItem
  1535.         ) use (
  1536.             $arrConfig,
  1537.             &$arrGalleries
  1538.         ) {
  1539.             if (!$objItem->hasProduct()) {
  1540.                 return new StandardGallery();
  1541.             }
  1543.             $strCacheKey         = 'product' . $objItem->product_id . '_' . $strAttribute;
  1544.             $arrConfig['jumpTo'] = $objItem->getRelated('jumpTo');
  1546.             if (!isset($arrGalleries[$strCacheKey])) {
  1547.                 $arrGalleries[$strCacheKey] = Gallery::createForProductAttribute(
  1548.                     $objItem->getProduct(),
  1549.                     $strAttribute,
  1550.                     $arrConfig
  1551.                 );
  1552.             }
  1554.             return $arrGalleries[$strCacheKey];
  1555.         };
  1557.         $objTemplate->attributeLabel = function ($name, array $options = []) {
  1558.             /** @var Attribute $attribute */
  1559.             $attribute = $GLOBALS['TL_DCA']['tl_iso_product']['attributes'][$name] ?? null;
  1561.             if (!$attribute instanceof IsotopeAttribute) {
  1562.                 return Format::dcaLabel('tl_iso_product', $name);
  1563.             }
  1565.             return $attribute->getLabel($options);
  1566.         };
  1568.         $objTemplate->attributeValue = function ($name, $value, array $options = []) {
  1569.             /** @var Attribute $attribute */
  1570.             $attribute = $GLOBALS['TL_DCA']['tl_iso_product']['attributes'][$name] ?? null;
  1572.             if (!$attribute instanceof IsotopeAttribute) {
  1573.                 return Format::dcaValue('tl_iso_product', $name, $value);
  1574.             }
  1576.             return $attribute->generateValue($value, $options);
  1577.         };
  1579.         // !HOOK: allow overriding of the template
  1580.         if (isset($GLOBALS['ISO_HOOKS']['addCollectionToTemplate'])
  1581.             && \is_array($GLOBALS['ISO_HOOKS']['addCollectionToTemplate'])
  1582.         ) {
  1583.             foreach ($GLOBALS['ISO_HOOKS']['addCollectionToTemplate'] as $callback) {
  1584.                 System::importStatic($callback[0])->{$callback[1]}($objTemplate, $arrItems, $this, $arrConfig);
  1585.             }
  1586.         }
  1587.     }
  1589.     /**
  1590.      * @inheritdoc
  1591.      */
  1592.     public function addError($message)
  1593.     {
  1594.         $this->arrErrors[] = $message;
  1595.     }
  1597.     /**
  1598.      * @inheritdoc
  1599.      */
  1600.     public function hasErrors()
  1601.     {
  1602.         if (\count($this->arrErrors) > 0) {
  1603.             return true;
  1604.         }
  1606.         foreach ($this->getItems() as $objItem) {
  1607.             if ($objItem->hasErrors()) {
  1608.                 return true;
  1609.             }
  1610.         }
  1612.         return false;
  1613.     }
  1615.     /**
  1616.      * @inheritdoc
  1617.      */
  1618.     public function getErrors()
  1619.     {
  1620.         $arrErrors = $this->arrErrors;
  1622.         foreach ($this->getItems() as $objItem) {
  1623.             if ($objItem->hasErrors()) {
  1624.                 array_unshift($arrErrors, $this->getMessageIfErrorsInItems());
  1625.                 break;
  1626.             }
  1627.         }
  1629.         return $arrErrors;
  1630.     }
  1632.     /**
  1633.      * Loop over items and add them to template
  1634.      *
  1635.      * @param Callable  $varCallable
  1636.      *
  1637.      * @return array
  1638.      */
  1639.     protected function addItemsToTemplate(Template $objTemplate, $varCallable = null)
  1640.     {
  1641.         $taxIds   = array();
  1642.         $arrItems = array();
  1644.         foreach ($this->getItems($varCallable) as $objItem) {
  1645.             $item = $this->generateItem($objItem);
  1647.             $taxIds[]   = $item['tax_id'];
  1648.             $arrItems[] = $item;
  1649.         }
  1651.         RowClass::withKey('rowClass')->addCount('row_')->addFirstLast('row_')->addEvenOdd('row_')->applyTo($arrItems);
  1653.         $objTemplate->items         = $arrItems;
  1654.         $objTemplate->total_tax_ids = \count(array_unique($taxIds));
  1656.         return $arrItems;
  1657.     }
  1659.     /**
  1660.      * Generate item array for template
  1661.      *
  1662.      * @param ProductCollectionItem $objItem
  1663.      *
  1664.      * @return array
  1665.      */
  1666.     protected function generateItem(ProductCollectionItem $objItem)
  1667.     {
  1668.         $blnHasProduct = $objItem->hasProduct();
  1669.         $objProduct    = $objItem->getProduct();
  1670.         $objConfig     = $this->getRelated('config_id') ?: Isotope::getConfig();
  1671.         $arrCSS        = ($blnHasProduct ? StringUtil::deserialize($objProduct->cssID, true) : array());
  1673.         // Set the active product for insert tags replacement
  1674.         if ($blnHasProduct) {
  1675.             Product::setActive($objProduct);
  1676.         }
  1678.         $arrItem = array(
  1679.             'id'                => $objItem->id,
  1680.             'sku'               => $objItem->getSku(),
  1681.             'name'              => $objItem->getName(),
  1682.             'options'           => Isotope::formatOptions($objItem->getOptions()),
  1683.             'configuration'     => $objItem->getConfiguration(),
  1684.             'attributes'        => $objItem->getAttributes(),
  1685.             'quantity'          => $objItem->quantity,
  1686.             'price'             => Isotope::formatPriceWithCurrency($objItem->getPrice(), true, $objConfig->currency),
  1687.             'tax_free_price'    => Isotope::formatPriceWithCurrency($objItem->getTaxFreePrice(), true, $objConfig->currency),
  1688.             'original_price'    => Isotope::formatPriceWithCurrency($objItem->getOriginalPrice(), true, $objConfig->currency),
  1689.             'total'             => Isotope::formatPriceWithCurrency($objItem->getTotalPrice(), true, $objConfig->currency),
  1690.             'tax_free_total'    => Isotope::formatPriceWithCurrency($objItem->getTaxFreeTotalPrice(), true, $objConfig->currency),
  1691.             'original_total'    => Isotope::formatPriceWithCurrency($objItem->getTotalOriginalPrice(), true, $objConfig->currency),
  1692.             'tax_id'            => $objItem->tax_id,
  1693.             'href'              => false,
  1694.             'hasProduct'        => $blnHasProduct,
  1695.             'product'           => $objProduct,
  1696.             'item'              => $objItem,
  1697.             'raw'               => $objItem->row(),
  1698.             'rowClass'          => trim('product ' . (($blnHasProduct && $objProduct->isNew()) ? 'new ' : '') . ($arrCSS[1] ?? ''))
  1699.         );
  1701.         if ($blnHasProduct && null !== $objItem->getRelated('jumpTo') && $objProduct->isAvailableInFrontend()) {
  1702.             $arrItem['href'] = $objProduct->generateUrl($objItem->getRelated('jumpTo'));
  1703.         }
  1705.         Product::unsetActive();
  1707.         return $arrItem;
  1708.     }
  1710.     /**
  1711.      * Get a collection-specific error message for items with errors
  1712.      *
  1713.      * @return string
  1714.      */
  1715.     protected function getMessageIfErrorsInItems()
  1716.     {
  1717.         return $GLOBALS['TL_LANG']['ERR']['collectionErrorInItems'];
  1718.     }
  1720.     /**
  1721.      * Generate the next higher Document Number based on existing records
  1722.      *
  1723.      * @param string $strPrefix
  1724.      * @param int    $intDigits
  1725.      *
  1726.      * @return string
  1727.      * @throws \Exception
  1728.      */
  1729.     protected function generateDocumentNumber($strPrefix, $intDigits)
  1730.     {
  1731.         if ($this->arrData['document_number'] != '') {
  1732.             return $this->arrData['document_number'];
  1733.         }
  1735.         // !HOOK: generate a custom order ID
  1736.         if (isset($GLOBALS['ISO_HOOKS']['generateDocumentNumber'])
  1737.             && \is_array($GLOBALS['ISO_HOOKS']['generateDocumentNumber'])
  1738.         ) {
  1739.             foreach ($GLOBALS['ISO_HOOKS']['generateDocumentNumber'] as $callback) {
  1740.                 $strOrderId  = System::importStatic($callback[0])->{$callback[1]}($this, $strPrefix, $intDigits);
  1742.                 if ($strOrderId !== false) {
  1743.                     $this->arrData['document_number'] = $strOrderId;
  1744.                     break;
  1745.                 }
  1746.             }
  1747.         }
  1749.         try {
  1750.             if ($this->arrData['document_number'] == '') {
  1751.                 $strPrefix = Controller::replaceInsertTags($strPrefix, false);
  1752.                 $intPrefix = utf8_strlen($strPrefix);
  1754.                 // Lock tables so no other order can get the same ID
  1755.                 Database::getInstance()->lockTables(array(static::$strTable => 'WRITE'));
  1757.                 $prefixCondition = ($strPrefix != '' ? " AND document_number LIKE '$strPrefix%'" : '');
  1759.                 // Retrieve the highest available order ID
  1760.                 $objMax = Database::getInstance()
  1761.                     ->prepare("
  1762.                         SELECT document_number
  1763.                         FROM tl_iso_product_collection
  1764.                         WHERE
  1765.                             type=?
  1766.                             $prefixCondition
  1767.                             AND store_id=?
  1768.                         ORDER BY CAST(" . ($strPrefix != '' ? 'SUBSTRING(document_number, ' . ($intPrefix + 1) . ')' : 'document_number') . ' AS UNSIGNED) DESC
  1769.                     ')
  1770.                     ->limit(1)
  1771.                     ->execute(
  1772.                         array_search(\get_called_class(), static::getModelTypes(), true),
  1773.                         $this->store_id
  1774.                     )
  1775.                 ;
  1777.                 $intMax = (int) substr($objMax->document_number, $intPrefix);
  1779.                 $this->arrData['document_number'] = $strPrefix . str_pad($intMax + 1, $intDigits, '0', STR_PAD_LEFT);
  1780.             }
  1782.             Database::getInstance()
  1783.                 ->prepare('UPDATE tl_iso_product_collection SET document_number=? WHERE id=?')
  1784.                 ->execute($this->arrData['document_number'], $this->id)
  1785.             ;
  1787.             Database::getInstance()->unlockTables();
  1789.         } catch (\Exception $e) {
  1790.             // Make sure tables are always unlocked
  1791.             Database::getInstance()->unlockTables();
  1793.             throw $e;
  1794.         }
  1796.         return $this->arrData['document_number'];
  1797.     }
  1799.     /**
  1800.      * Generate a unique ID for this collection
  1801.      *
  1802.      * @return string
  1803.      */
  1804.     protected function generateUniqueId()
  1805.     {
  1806.         if (!empty($this->arrData['uniqid'])) {
  1807.             return $this->arrData['uniqid'];
  1808.         }
  1810.         return uniqid('', true);
  1811.     }
  1813.     /**
  1814.      * Prevent modifying a locked collection
  1815.      *
  1816.      * @throws \BadMethodCallException if the collection is locked.
  1817.      */
  1818.     protected function ensureNotLocked()
  1819.     {
  1820.         if ($this->isLocked()) {
  1821.             throw new \BadMethodCallException('Product collection is locked');
  1822.         }
  1823.     }
  1825.     /**
  1826.      * Make sure the addresses belong to this collection only, so they will never be modified
  1827.      *
  1828.      * @throws \UnderflowException if collection is not saved (not in DB)
  1829.      * @throws \BadMethodCallException if the product collection is locked.
  1830.      */
  1831.     protected function createPrivateAddresses()
  1832.     {
  1833.         $this->ensureNotLocked();
  1835.         if (!$this->id) {
  1836.             throw new \UnderflowException('Product collection must be saved before creating unique addresses.');
  1837.         }
  1839.         $canSkip = StringUtil::deserialize($this->iso_checkout_skippable, true);
  1840.         $objBillingAddress  = $this->getBillingAddress();
  1841.         $objShippingAddress = $this->getShippingAddress();
  1843.         // Store address in address book
  1844.         if ($this->iso_addToAddressbook && $this->member > 0) {
  1845.             if (null !== $objBillingAddress
  1846.                 && $objBillingAddress->ptable != MemberModel::getTable()
  1847.                 && !\in_array('billing_address', $canSkip, true)
  1848.             ) {
  1849.                 $objAddress         = clone $objBillingAddress;
  1850.                 $objAddress->pid    = $this->member;
  1851.                 $objAddress->tstamp = time();
  1852.                 $objAddress->ptable = MemberModel::getTable();
  1853.                 $objAddress->store_id = $this->store_id;
  1854.                 $objAddress->save();
  1856.                 $this->updateDefaultAddress($objAddress);
  1857.             }
  1859.             if (null !== $objBillingAddress
  1860.                 && null !== $objShippingAddress
  1861.                 && $objBillingAddress->id != $objShippingAddress->id
  1862.                 && $objShippingAddress->ptable != MemberModel::getTable()
  1863.                 && !\in_array('shipping_address', $canSkip, true)
  1864.             ) {
  1865.                 $objAddress         = clone $objShippingAddress;
  1866.                 $objAddress->pid    = $this->member;
  1867.                 $objAddress->tstamp = time();
  1868.                 $objAddress->ptable = MemberModel::getTable();
  1869.                 $objAddress->store_id = $this->store_id;
  1870.                 $objAddress->save();
  1872.                 $this->updateDefaultAddress($objAddress);
  1873.             }
  1874.         }
  1876.         /** @var Config $config */
  1877.         $config         = $this->getRelated('config_id');
  1878.         $billingFields  = (null === $config) ? array() : $config->getBillingFields();
  1879.         $shippingFields = (null === $config) ? array() : $config->getShippingFields();
  1881.         if (null !== $objBillingAddress
  1882.             && ($objBillingAddress->ptable != static::$strTable || $objBillingAddress->pid != $this->id)
  1883.         ) {
  1884.             $arrData = array_intersect_key(
  1885.                 $objBillingAddress->row(),
  1886.                 array_merge(array_flip($billingFields), ['country' => ''])
  1887.             );
  1889.             $objNew = new Address();
  1890.             $objNew->setRow($arrData);
  1892.             $objNew->pid      = $this->id;
  1893.             $objNew->tstamp   = time();
  1894.             $objNew->ptable   = static::$strTable;
  1895.             $objNew->store_id = $this->store_id;
  1896.             $objNew->save();
  1898.             $this->setBillingAddress($objNew);
  1900.             if (null !== $objShippingAddress && $objBillingAddress->id == $objShippingAddress->id) {
  1901.                 $this->setShippingAddress($objNew);
  1903.                 // Stop here, we do not need to check shipping address
  1904.                 return;
  1905.             }
  1906.         }
  1908.         if (null !== $objShippingAddress
  1909.             && ($objShippingAddress->ptable != static::$strTable || $objShippingAddress->pid != $this->id)
  1910.         ) {
  1911.             $arrData = array_intersect_key(
  1912.                 $objShippingAddress->row(),
  1913.                 array_merge(array_flip($shippingFields), ['country' => ''])
  1914.             );
  1916.             $objNew = new Address();
  1917.             $objNew->setRow($arrData);
  1919.             $objNew->pid      = $this->id;
  1920.             $objNew->tstamp   = time();
  1921.             $objNew->ptable   = static::$strTable;
  1922.             $objNew->store_id = $this->store_id;
  1923.             $objNew->save();
  1925.             $this->setShippingAddress($objNew);
  1926.         } elseif (null === $objShippingAddress) {
  1927.             // Make sure to set the shipping address to null if collection has no shipping
  1928.             // see isotope/core#2014
  1929.             $this->setShippingAddress(null);
  1930.         }
  1931.     }
  1933.     /**
  1934.      * Mark existing addresses as not default if the new address is default
  1935.      *
  1936.      * @param Address $objAddress
  1937.      */
  1938.     protected function updateDefaultAddress(Address $objAddress)
  1939.     {
  1940.         $arrSet = array();
  1942.         if ($objAddress->isDefaultBilling) {
  1943.             $arrSet['isDefaultBilling'] = '';
  1944.         }
  1946.         if ($objAddress->isDefaultShipping) {
  1947.             $arrSet['isDefaultShipping'] = '';
  1948.         }
  1950.         if (\count($arrSet) > 0) {
  1951.             Database::getInstance()
  1952.                 ->prepare('UPDATE tl_iso_address %s WHERE pid=? AND ptable=? AND store_id=? AND id!=?')
  1953.                 ->set($arrSet)
  1954.                 ->execute($this->member, MemberModel::getTable(), $this->store_id, $objAddress->id)
  1955.             ;
  1956.         }
  1957.     }
  1959.     /**
  1960.      * Clear all cache properties
  1961.      */
  1962.     protected function clearCache()
  1963.     {
  1964.         $this->arrItems = null;
  1965.         $this->arrSurcharges = null;
  1966.         $this->arrCache = null;
  1967.         $this->arrErrors = array();
  1968.         $this->objPayment = false;
  1969.         $this->objShipping = false;
  1970.     }
  1972.     /**
  1973.      * Initialize a new collection and duplicate everything from the source
  1974.      *
  1975.      * @param IsotopeProductCollection $objSource
  1976.      *
  1977.      * @return static
  1978.      */
  1979.     public static function createFromCollection(IsotopeProductCollection $objSource)
  1980.     {
  1981.         $objCollection = new static();
  1982.         $objConfig = $objSource->getConfig();
  1984.         if (null === $objConfig) {
  1985.             $objConfig = Isotope::getConfig();
  1986.         }
  1988.         $member = $objSource->getMember();
  1990.         $objCollection->source_collection_id = $objSource->getId();
  1991.         $objCollection->config_id            = (int) $objConfig->id;
  1992.         $objCollection->store_id             = (int) $objSource->getStoreId();
  1993.         $objCollection->member               = (null === $member ? 0 : $member->id);
  1995.         if ($objCollection instanceof IsotopeOrderableCollection
  1996.             && $objSource instanceof  IsotopeOrderableCollection)
  1997.         {
  1998.             $objCollection->setShippingMethod($objSource->getShippingMethod());
  1999.             $objCollection->setPaymentMethod($objSource->getPaymentMethod());
  2001.             $objCollection->setShippingAddress($objSource->getShippingAddress());
  2002.             $objCollection->setBillingAddress($objSource->getBillingAddress());
  2003.         }
  2005.         $arrItemIds = $objCollection->copyItemsFrom($objSource);
  2007.         $objCollection->updateDatabase();
  2009.         // HOOK: order status has been updated
  2010.         if (isset($GLOBALS['ISO_HOOKS']['createFromProductCollection'])
  2011.             && \is_array($GLOBALS['ISO_HOOKS']['createFromProductCollection'])
  2012.         ) {
  2013.             foreach ($GLOBALS['ISO_HOOKS']['createFromProductCollection'] as $callback) {
  2014.                 System::importStatic($callback[0])->{$callback[1]}($objCollection, $objSource, $arrItemIds);
  2015.             }
  2016.         }
  2018.         return $objCollection;
  2019.     }
  2021.     /**
  2022.      * Method that returns a closure to sort product collection items
  2023.      *
  2024.      * @param string $strOrderBy
  2025.      *
  2026.      * @return \Closure|null
  2027.      */
  2028.     public static function getItemsSortingCallable($strOrderBy = 'asc_id')
  2029.     {
  2030.         [$direction, $attribute] = explode('_', $strOrderBy, 2) + [null, null];
  2032.         if ('asc' === $direction) {
  2033.             return function ($arrItems) use ($attribute) {
  2034.                 uasort($arrItems, function ($objItem1, $objItem2) use ($attribute) {
  2035.                     if ($objItem1->$attribute == $objItem2->$attribute) {
  2036.                         return 0;
  2037.                     }
  2039.                     return $objItem1->$attribute < $objItem2->$attribute ? -1 : 1;
  2040.                 });
  2042.                 return $arrItems;
  2043.             };
  2045.         }
  2047.         if ('desc' === $direction) {
  2048.             return function ($arrItems) use ($attribute) {
  2049.                 uasort($arrItems, function ($objItem1, $objItem2) use ($attribute) {
  2050.                     if ($objItem1->$attribute == $objItem2->$attribute) {
  2051.                         return 0;
  2052.                     }
  2054.                     return $objItem1->$attribute > $objItem2->$attribute ? -1 : 1;
  2055.                 });
  2057.                 return $arrItems;
  2058.             };
  2059.         }
  2061.         return null;
  2062.     }
  2064.     /**
  2065.      * @param IsotopeProduct        $product
  2066.      * @param ProductCollectionItem $item
  2067.      * @param int                   $quantity
  2068.      */
  2069.     private function setProductForItem(IsotopeProduct $product, ProductCollectionItem $item, $quantity)
  2070.     {
  2071.         $item->tstamp         = time();
  2072.         $item->type           = array_search(\get_class($product), Product::getModelTypes(), true);
  2073.         $item->product_id     = (int) $product->getId();
  2074.         $item->sku            = (string) $product->getSku();
  2075.         $item->name           = (string) $product->getName();
  2076.         $item->configuration  = $product->getOptions();
  2077.         $item->quantity       = (int) $quantity;
  2078.         $item->price          = (float) ($product->getPrice($this) ? $product->getPrice($this)->getAmount((int) $quantity) : 0);
  2079.         $item->tax_free_price = (float) ($product->getPrice($this) ? $product->getPrice($this)->getNetAmount((int) $quantity) : 0);
  2080.     }
  2082.     /**
  2083.      * Check if product collection has tax
  2084.      *
  2085.      * @return bool
  2086.      */
  2087.     public function hasTax()
  2088.     {
  2089.         foreach ($this->getSurcharges() as $surcharge) {
  2090.             if ($surcharge instanceof Tax) {
  2091.                 return true;
  2092.             }
  2093.         }
  2095.         return false;
  2096.     }
  2097. }