vendor/pimcore/pimcore/models/DataObject/AbstractObject.php line 1195

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Model\DataObject;
  18. use Doctrine\DBAL\Exception\RetryableException;
  19. use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
  20. use Pimcore\Cache;
  21. use Pimcore\Cache\RuntimeCache;
  22. use Pimcore\Db;
  23. use Pimcore\Event\DataObjectEvents;
  24. use Pimcore\Event\Model\DataObjectEvent;
  25. use Pimcore\Logger;
  26. use Pimcore\Model;
  27. use Pimcore\Model\DataObject;
  28. use Pimcore\Model\Element;
  29. use Pimcore\Model\Element\DuplicateFullPathException;
  31. /**
  32.  * @method AbstractObject\Dao getDao()
  33.  * @method array|null getPermissions(?string $type, Model\User $user, bool $quote = true)
  34.  * @method bool __isBasedOnLatestData()
  35.  * @method string getCurrentFullPath()
  36.  * @method int getChildAmount($objectTypes = [DataObject::OBJECT_TYPE_OBJECT, DataObject::OBJECT_TYPE_FOLDER], Model\User $user = null)
  37.  * @method array getChildPermissions(?string $type, Model\User $user, bool $quote = true)
  38.  */
  39. abstract class AbstractObject extends Model\Element\AbstractElement
  40. {
  41.     const OBJECT_TYPE_FOLDER = 'folder';
  43.     const OBJECT_TYPE_OBJECT = 'object';
  45.     const OBJECT_TYPE_VARIANT = 'variant';
  47.     const OBJECT_CHILDREN_SORT_BY_DEFAULT = 'key';
  49.     const OBJECT_CHILDREN_SORT_BY_INDEX = 'index';
  51.     const OBJECT_CHILDREN_SORT_ORDER_DEFAULT = 'ASC';
  53.     /**
  54.      * possible types of a document
  55.      *
  56.      * @var array
  57.      */
  58.     public static $types = [self::OBJECT_TYPE_FOLDER, self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_VARIANT];
  60.     /**
  61.      * @var bool
  62.      */
  63.     private static $hideUnpublished = false;
  65.     /**
  66.      * @var bool
  67.      */
  68.     private static $getInheritedValues = false;
  70.     /**
  71.      * @internal
  72.      *
  73.      * @var bool
  74.      */
  75.     protected static $disableDirtyDetection = false;
  77.     /**
  78.      * @internal
  79.      *
  80.      * @var string[]
  81.      */
  82.     protected static $objectColumns = ['o_id', 'o_parentid', 'o_type', 'o_key', 'o_classid', 'o_classname', 'o_path'];
  84.     /**
  85.      * @internal
  86.      *
  87.      * @deprecated
  88.      *
  89.      * @var int|null
  90.      */
  91.     protected $o_id;
  93.     /**
  94.      * @internal
  95.      *
  96.      * @deprecated
  97.      *
  98.      * @var int|null
  99.      */
  100.     protected $o_parentId;
  102.     /**
  103.      * @internal
  104.      *
  105.      * @deprecated
  106.      */
  107.     protected $o_parent;
  109.     /**
  110.      * @internal
  111.      *
  112.      * @var string
  113.      */
  114.     protected $o_type = 'object';
  116.     /**
  117.      * @internal
  118.      *
  119.      * @var string|null
  120.      */
  121.     protected $o_key;
  123.     /**
  124.      * @internal
  125.      *
  126.      * @deprecated
  127.      *
  128.      * @var string|null
  129.      */
  130.     protected $o_path;
  132.     /**
  133.      * @internal
  134.      *
  135.      * @var int
  136.      */
  137.     protected $o_index = 0;
  139.     /**
  140.      * @internal
  141.      *
  142.      * @deprecated
  143.      *
  144.      * @var int|null
  145.      */
  146.     protected $o_creationDate;
  148.     /**
  149.      * @internal
  150.      *
  151.      * @deprecated
  152.      *
  153.      * @var int|null
  154.      */
  155.     protected $o_modificationDate;
  157.     /**
  158.      * @internal
  159.      *
  160.      * @deprecated
  161.      *
  162.      * @var int|null
  163.      */
  164.     protected ?int $o_userOwner = null;
  166.     /**
  167.      * @internal
  168.      *
  169.      * @deprecated
  170.      *
  171.      * @var int|null
  172.      */
  173.     protected ?int $o_userModification = null;
  175.     /**
  176.      * @internal
  177.      *
  178.      * @var bool[]
  179.      */
  180.     protected $o_hasChildren = [];
  182.     /**
  183.      * Contains a list of sibling documents
  184.      *
  185.      * @internal
  186.      *
  187.      * @var array
  188.      */
  189.     protected $o_siblings = [];
  191.     /**
  192.      * Indicator if object has siblings or not
  193.      *
  194.      * @internal
  195.      *
  196.      * @var bool[]
  197.      */
  198.     protected $o_hasSiblings = [];
  200.     /**
  201.      * @internal
  202.      *
  203.      * @var array
  204.      */
  205.     protected $o_children = [];
  207.     /**
  208.      * @internal
  209.      *
  210.      * @deprecated
  211.      *
  212.      * @var string
  213.      */
  214.     protected $o_locked;
  216.     /**
  217.      * @internal
  218.      *
  219.      * @var string|null
  220.      */
  221.     protected $o_childrenSortBy;
  223.     /**
  224.      * @internal
  225.      *
  226.      * @var string|null
  227.      */
  228.     protected $o_childrenSortOrder;
  230.     /**
  231.      * @internal
  232.      *
  233.      * @deprecated
  234.      *
  235.      * @var int
  236.      */
  237.     protected $o_versionCount = 0;
  239.     /**
  240.      * @internal
  241.      *
  242.      * @deprecated
  243.      *
  244.      * @var array|null
  245.      */
  246.     protected $o_properties = null;
  248.     public function __construct()
  249.     {
  250.         $this->o_id = & $this->id;
  251.         $this->o_path = & $this->path;
  252.         $this->o_creationDate = & $this->creationDate;
  253.         $this->o_userOwner = & $this->userOwner;
  254.         $this->o_versionCount = & $this->versionCount;
  255.         $this->o_modificationDate = & $this->modificationDate;
  256.         $this->o_locked = & $this->locked;
  257.         $this->o_parent = & $this->parent;
  258.         $this->o_properties = & $this->properties;
  259.         $this->o_userModification = & $this->userModification;
  260.         $this->o_parentId = & $this->parentId;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     protected function getBlockedVars(): array
  267.     {
  268.         $blockedVars = ['o_hasChildren', 'o_versions', 'o_class', 'scheduledTasks', 'o_parent', 'parent', 'omitMandatoryCheck'];
  270.         if ($this->isInDumpState()) {
  271.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  272.             $blockedVars = array_merge($blockedVars, ['o_dirtyFields']);
  273.         } else {
  274.             // this is if we want to cache the object
  275.             $blockedVars = array_merge($blockedVars, ['o_children', 'properties', 'o_properties']);
  276.         }
  278.         return $blockedVars;
  279.     }
  281.     /**
  282.      * @static
  283.      *
  284.      * @return bool
  285.      */
  286.     public static function getHideUnpublished()
  287.     {
  288.         return self::$hideUnpublished;
  289.     }
  291.     /**
  292.      * @static
  293.      *
  294.      * @param bool $hideUnpublished
  295.      */
  296.     public static function setHideUnpublished($hideUnpublished)
  297.     {
  298.         self::$hideUnpublished = $hideUnpublished;
  299.     }
  301.     /**
  302.      * @static
  303.      *
  304.      * @return bool
  305.      */
  306.     public static function doHideUnpublished()
  307.     {
  308.         return self::$hideUnpublished;
  309.     }
  311.     /**
  312.      * @static
  313.      *
  314.      * @param bool $getInheritedValues
  315.      */
  316.     public static function setGetInheritedValues($getInheritedValues)
  317.     {
  318.         self::$getInheritedValues = $getInheritedValues;
  319.     }
  321.     /**
  322.      * @static
  323.      *
  324.      * @return bool
  325.      */
  326.     public static function getGetInheritedValues()
  327.     {
  328.         return self::$getInheritedValues;
  329.     }
  331.     /**
  332.      * @static
  333.      *
  334.      * @param Concrete|null $object
  335.      *
  336.      * @return bool
  337.      */
  338.     public static function doGetInheritedValues(Concrete $object = null)
  339.     {
  340.         if (self::$getInheritedValues && $object !== null) {
  341.             $class = $object->getClass();
  343.             return $class->getAllowInherit();
  344.         }
  346.         return self::$getInheritedValues;
  347.     }
  349.     /**
  350.      * get possible types
  351.      *
  352.      * @return array
  353.      */
  354.     public static function getTypes()
  355.     {
  356.         return self::$types;
  357.     }
  359.     /**
  360.      * Static helper to get an object by the passed ID
  361.      *
  362.      * @param int|string $id
  363.      * @param array|bool $force
  364.      *
  365.      * @return static|null
  366.      */
  367.     public static function getById($id, $force = false)
  368.     {
  369.         if (!is_numeric($id) || $id < 1) {
  370.             return null;
  371.         }
  373.         $id = (int)$id;
  374.         $cacheKey = self::getCacheKey($id);
  376.         $params = Model\Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  378.         if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  379.             $object = RuntimeCache::get($cacheKey);
  380.             if ($object && static::typeMatch($object)) {
  381.                 return $object;
  382.             }
  383.         }
  385.         if ($params['force'] || !($object = Cache::load($cacheKey))) {
  386.             $object = new Model\DataObject();
  388.             try {
  389.                 $typeInfo = $object->getDao()->getTypeById($id);
  391.                 if (!empty($typeInfo['o_type']) && in_array($typeInfo['o_type'], DataObject::$types)) {
  392.                     if ($typeInfo['o_type'] == DataObject::OBJECT_TYPE_FOLDER) {
  393.                         $className = Folder::class;
  394.                     } else {
  395.                         $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($typeInfo['o_className']);
  396.                     }
  398.                     /** @var AbstractObject $object */
  399.                     $object = self::getModelFactory()->build($className);
  400.                     RuntimeCache::set($cacheKey, $object);
  401.                     $object->getDao()->getById($id);
  402.                     $object->__setDataVersionTimestamp($object->getModificationDate());
  404.                     Service::recursiveResetDirtyMap($object);
  406.                     // force loading of relation data
  407.                     if ($object instanceof Concrete) {
  408.                         $object->__getRawRelationData();
  409.                     }
  411.                     Cache::save($object, $cacheKey);
  412.                 } else {
  413.                     throw new Model\Exception\NotFoundException('No entry for object id ' . $id);
  414.                 }
  415.             } catch (Model\Exception\NotFoundException $e) {
  416.                 return null;
  417.             }
  418.         } else {
  419.             RuntimeCache::set($cacheKey, $object);
  420.         }
  422.         if (!$object || !static::typeMatch($object)) {
  423.             return null;
  424.         }
  426.         \Pimcore::getEventDispatcher()->dispatch(
  427.             new DataObjectEvent($object, ['params' => $params]),
  428.             DataObjectEvents::POST_LOAD
  429.         );
  431.         return $object;
  432.     }
  434.     /**
  435.      * @param string $path
  436.      * @param array|bool $force
  437.      *
  438.      * @return static|null
  439.      */
  440.     public static function getByPath($path, $force = false)
  441.     {
  442.         if (!$path) {
  443.             return null;
  444.         }
  446.         $path = Model\Element\Service::correctPath($path);
  448.         try {
  449.             $object = new static();
  450.             $object->getDao()->getByPath($path);
  452.             return static::getById($object->getId(), Model\Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1));
  453.         } catch (Model\Exception\NotFoundException $e) {
  454.             return null;
  455.         }
  456.     }
  458.     /**
  459.      * @param array $config
  460.      *
  461.      * @return DataObject\Listing
  462.      *
  463.      * @throws \Exception
  464.      */
  465.     public static function getList($config = [])
  466.     {
  467.         $className = DataObject::class;
  468.         // get classname
  469.         if (!in_array(static::class, [__CLASS__, Concrete::class, Folder::class], true)) {
  470.             /** @var Concrete $tmpObject */
  471.             $tmpObject = new static();
  472.             if ($tmpObject instanceof Concrete) {
  473.                 $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($tmpObject->getClassName());
  474.             }
  475.         }
  477.         if (is_array($config)) {
  478.             if (!empty($config['class'])) {
  479.                 $className = ltrim($config['class'], '\\');
  480.             }
  482.             if ($className) {
  483.                 $listClass = $className . '\\Listing';
  484.                 /** @var DataObject\Listing $list */
  485.                 $list = self::getModelFactory()->build($listClass);
  486.                 $list->setValues($config);
  488.                 return $list;
  489.             }
  490.         }
  492.         throw new \Exception('Unable to initiate list class - class not found or invalid configuration');
  493.     }
  495.     /**
  496.      * @deprecated will be removed in Pimcore 11
  497.      *
  498.      * @param array $config
  499.      *
  500.      * @return int total count
  501.      */
  502.     public static function getTotalCount($config = [])
  503.     {
  504.         $list = static::getList($config);
  505.         $count = $list->getTotalCount();
  507.         return $count;
  508.     }
  510.     /**
  511.      * @internal
  512.      *
  513.      * @param AbstractObject $object
  514.      *
  515.      * @return bool
  516.      */
  517.     protected static function typeMatch(AbstractObject $object)
  518.     {
  519.         if (static::class === Concrete::class && !$object instanceof static) {
  520.             trigger_deprecation(
  521.                 'pimcore/pimcore',
  522.                 '10.5',
  523.                 'Loading non-Concrete objects with the Concrete class will not be possible in Pimcore 11'
  524.             );
  526.             return true;
  527.         }
  529.         return static::class === self::class || $object instanceof static;
  530.     }
  532.     /**
  533.      * @param array $objectTypes
  534.      * @param bool $includingUnpublished
  535.      *
  536.      * @return DataObject[]
  537.      */
  538.     public function getChildren(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  539.     {
  540.         $cacheKey = $this->getListingCacheKey(func_get_args());
  542.         if (!isset($this->o_children[$cacheKey])) {
  543.             if ($this->getId()) {
  544.                 $list = new Listing();
  545.                 $list->setUnpublished($includingUnpublished);
  546.                 $list->setCondition('o_parentId = ?', $this->getId());
  547.                 $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  548.                 $list->setOrder($this->getChildrenSortOrder());
  549.                 $list->setObjectTypes($objectTypes);
  550.                 $this->o_children[$cacheKey] = $list->load();
  551.                 $this->o_hasChildren[$cacheKey] = (bool) count($this->o_children[$cacheKey]);
  552.             } else {
  553.                 $this->o_children[$cacheKey] = [];
  554.                 $this->o_hasChildren[$cacheKey] = false;
  555.             }
  556.         }
  558.         return $this->o_children[$cacheKey];
  559.     }
  561.     /**
  562.      * Quick test if there are children
  563.      *
  564.      * @param array $objectTypes
  565.      * @param bool|null $includingUnpublished
  566.      *
  567.      * @return bool
  568.      */
  569.     public function hasChildren($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  570.     {
  571.         $cacheKey = $this->getListingCacheKey(func_get_args());
  573.         if (isset($this->o_hasChildren[$cacheKey])) {
  574.             return $this->o_hasChildren[$cacheKey];
  575.         }
  577.         return $this->o_hasChildren[$cacheKey] = $this->getDao()->hasChildren($objectTypes, $includingUnpublished);
  578.     }
  580.     /**
  581.      * Get a list of the sibling documents
  582.      *
  583.      * @param array $objectTypes
  584.      * @param bool $includingUnpublished
  585.      *
  586.      * @return array
  587.      */
  588.     public function getSiblings(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  589.     {
  590.         $cacheKey = $this->getListingCacheKey(func_get_args());
  592.         if (!isset($this->o_siblings[$cacheKey])) {
  593.             if ($this->getParentId()) {
  594.                 $list = new Listing();
  595.                 $list->setUnpublished($includingUnpublished);
  596.                 $list->addConditionParam('o_parentId = ?', $this->getParentId());
  597.                 if ($this->getId()) {
  598.                     $list->addConditionParam('o_id != ?', $this->getId());
  599.                 }
  600.                 $list->setOrderKey('o_key');
  601.                 $list->setObjectTypes($objectTypes);
  602.                 $list->setOrder('asc');
  603.                 $this->o_siblings[$cacheKey] = $list->load();
  604.                 $this->o_hasSiblings[$cacheKey] = (bool) count($this->o_siblings[$cacheKey]);
  605.             } else {
  606.                 $this->o_siblings[$cacheKey] = [];
  607.                 $this->o_hasSiblings[$cacheKey] = false;
  608.             }
  609.         }
  611.         return $this->o_siblings[$cacheKey];
  612.     }
  614.     /**
  615.      * Returns true if the object has at least one sibling
  616.      *
  617.      * @param array $objectTypes
  618.      * @param bool|null $includingUnpublished
  619.      *
  620.      * @return bool
  621.      */
  622.     public function hasSiblings($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  623.     {
  624.         $cacheKey = $this->getListingCacheKey(func_get_args());
  626.         if (isset($this->o_hasSiblings[$cacheKey])) {
  627.             return $this->o_hasSiblings[$cacheKey];
  628.         }
  630.         return $this->o_hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($objectTypes, $includingUnpublished);
  631.     }
  633.     /**
  634.      * @internal
  635.      *
  636.      * @throws \Exception
  637.      */
  638.     protected function doDelete()
  639.     {
  640.         // delete children
  641.         $children = $this->getChildren(self::$types, true);
  642.         if (count($children) > 0) {
  643.             foreach ($children as $child) {
  644.                 $child->delete();
  645.             }
  646.         }
  648.         // remove dependencies
  649.         $d = new Model\Dependency;
  650.         $d->cleanAllForElement($this);
  652.         // remove all properties
  653.         $this->getDao()->deleteAllProperties();
  654.     }
  656.     /**
  657.      * @throws \Exception
  658.      */
  659.     public function delete()
  660.     {
  661.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::PRE_DELETE);
  663.         $this->beginTransaction();
  665.         try {
  666.             $this->doDelete();
  667.             $this->getDao()->delete();
  669.             $this->commit();
  671.             //clear parent data from registry
  672.             $parentCacheKey = self::getCacheKey($this->getParentId());
  673.             if (RuntimeCache::isRegistered($parentCacheKey)) {
  674.                 /** @var AbstractObject $parent * */
  675.                 $parent = RuntimeCache::get($parentCacheKey);
  676.                 if ($parent instanceof self) {
  677.                     $parent->setChildren(null);
  678.                 }
  679.             }
  680.         } catch (\Exception $e) {
  681.             try {
  682.                 $this->rollBack();
  683.             } catch (\Exception $er) {
  684.                 // PDO adapter throws exceptions if rollback fails
  685.                 Logger::info((string) $er);
  686.             }
  688.             $failureEvent = new DataObjectEvent($this);
  689.             $failureEvent->setArgument('exception', $e);
  690.             $this->dispatchEvent($failureEvent, DataObjectEvents::POST_DELETE_FAILURE);
  692.             Logger::crit((string) $e);
  694.             throw $e;
  695.         }
  697.         // empty object cache
  698.         $this->clearDependentCache();
  700.         //clear object from registry
  701.         RuntimeCache::set(self::getCacheKey($this->getId()), null);
  703.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::POST_DELETE);
  704.     }
  706.     /**
  707.      * @return $this
  708.      *
  709.      * @throws \Exception
  710.      */
  711.     public function save()
  712.     {
  713.         // additional parameters (e.g. "versionNote" for the version note)
  714.         $params = [];
  715.         if (func_num_args() && is_array(func_get_arg(0))) {
  716.             $params = func_get_arg(0);
  717.         }
  719.         $isUpdate = false;
  720.         $differentOldPath = null;
  722.         try {
  723.             $isDirtyDetectionDisabled = self::isDirtyDetectionDisabled();
  724.             $preEvent = new DataObjectEvent($this, $params);
  725.             if ($this->getId()) {
  726.                 $isUpdate = true;
  727.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_UPDATE);
  728.             } else {
  729.                 self::disableDirtyDetection();
  730.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_ADD);
  731.             }
  733.             $params = $preEvent->getArguments();
  735.             $this->correctPath();
  737.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  738.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  739.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  740.             $maxRetries = 5;
  741.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  742.                 // be sure that unpublished objects in relations are saved also in frontend mode, eg. in importers, ...
  743.                 $hideUnpublishedBackup = self::getHideUnpublished();
  744.                 self::setHideUnpublished(false);
  746.                 $this->beginTransaction();
  748.                 try {
  749.                     if (!in_array($this->getType(), self::$types)) {
  750.                         throw new \Exception('invalid object type given: [' . $this->getType() . ']');
  751.                     }
  753.                     if (!$isUpdate) {
  754.                         $this->getDao()->create();
  755.                     }
  757.                     // get the old path from the database before the update is done
  758.                     $oldPath = null;
  759.                     if ($isUpdate) {
  760.                         $oldPath = $this->getDao()->getCurrentFullPath();
  761.                     }
  763.                     // if the old path is different from the new path, update all children
  764.                     // we need to do the update of the children's path before $this->update() because the
  765.                     // inheritance helper needs the correct paths of the children in InheritanceHelper::buildTree()
  766.                     $updatedChildren = [];
  767.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  768.                         $differentOldPath = $oldPath;
  769.                         $this->getDao()->updateWorkspaces();
  770.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  771.                     }
  773.                     $this->update($isUpdate, $params);
  775.                     self::setHideUnpublished($hideUnpublishedBackup);
  777.                     $this->commit();
  779.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  780.                 } catch (\Exception $e) {
  781.                     try {
  782.                         $this->rollBack();
  783.                     } catch (\Exception $er) {
  784.                         // PDO adapter throws exceptions if rollback fails
  785.                         Logger::info((string) $er);
  786.                     }
  788.                     // set "HideUnpublished" back to the value it was originally
  789.                     self::setHideUnpublished($hideUnpublishedBackup);
  791.                     if ($e instanceof UniqueConstraintViolationException) {
  792.                         throw new Element\ValidationException('unique constraint violation', 0, $e);
  793.                     }
  795.                     if ($e instanceof RetryableException) {
  796.                         // we try to start the transaction $maxRetries times again (deadlocks, ...)
  797.                         if ($retries < ($maxRetries - 1)) {
  798.                             $run = $retries + 1;
  799.                             $waitTime = random_int(1, 5) * 100000; // microseconds
  800.                             Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  802.                             usleep($waitTime); // wait specified time until we restart the transaction
  803.                         } else {
  804.                             // if the transaction still fail after $maxRetries retries, we throw out the exception
  805.                             Logger::error('Finally giving up restarting the same transaction again and again, last message: ' . $e->getMessage());
  807.                             throw $e;
  808.                         }
  809.                     } else {
  810.                         throw $e;
  811.                     }
  812.                 }
  813.             }
  815.             $additionalTags = [];
  816.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  817.                 foreach ($updatedChildren as $objectId) {
  818.                     $tag = 'object_' . $objectId;
  819.                     $additionalTags[] = $tag;
  821.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  822.                     RuntimeCache::set($tag, null);
  823.                 }
  824.             }
  825.             $this->clearDependentCache($additionalTags);
  827.             $postEvent = new DataObjectEvent($this, $params);
  828.             if ($isUpdate) {
  829.                 if ($differentOldPath) {
  830.                     $postEvent->setArgument('oldPath', $differentOldPath);
  831.                 }
  832.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_UPDATE);
  833.             } else {
  834.                 self::setDisableDirtyDetection($isDirtyDetectionDisabled);
  835.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_ADD);
  836.             }
  838.             return $this;
  839.         } catch (\Exception $e) {
  840.             $failureEvent = new DataObjectEvent($this, $params);
  841.             $failureEvent->setArgument('exception', $e);
  842.             if ($isUpdate) {
  843.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_UPDATE_FAILURE);
  844.             } else {
  845.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_ADD_FAILURE);
  846.             }
  848.             throw $e;
  849.         }
  850.     }
  852.     /**
  853.      * @internal
  854.      *
  855.      * @throws \Exception|DuplicateFullPathException
  856.      */
  857.     protected function correctPath()
  858.     {
  859.         // set path
  860.         if ($this->getId() != 1) { // not for the root node
  861.             if (!Element\Service::isValidKey($this->getKey(), 'object')) {
  862.                 throw new \Exception('invalid key for object with id [ '.$this->getId().' ] key is: [' . $this->getKey() . ']');
  863.             }
  865.             if ($this->getParentId() == $this->getId()) {
  866.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  867.             }
  869.             $parent = DataObject::getById($this->getParentId());
  871.             if ($parent) {
  872.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  873.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  874.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath().'/'));
  875.             } else {
  876.                 trigger_deprecation(
  877.                     'pimcore/pimcore',
  878.                     '10.5',
  879.                     'Fallback for parentId will be removed in Pimcore 11.',
  880.                 );
  881.                 // parent document doesn't exist anymore, set the parent to to root
  882.                 $this->setParentId(1);
  883.                 $this->setPath('/');
  884.             }
  886.             if (strlen($this->getKey()) < 1) {
  887.                 throw new \Exception('DataObject requires key');
  888.             }
  889.         } elseif ($this->getId() == 1) {
  890.             // some data in root node should always be the same
  891.             $this->setParentId(0);
  892.             $this->setPath('/');
  893.             $this->setKey('');
  894.             $this->setType(DataObject::OBJECT_TYPE_FOLDER);
  895.         }
  897.         if (Service::pathExists($this->getRealFullPath())) {
  898.             $duplicate = DataObject::getByPath($this->getRealFullPath());
  899.             if ($duplicate instanceof self && $duplicate->getId() != $this->getId()) {
  900.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ '.$this->getRealFullPath().' ] - cannot save object');
  901.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  903.                 throw $duplicateFullPathException;
  904.             }
  905.         }
  907.         $this->validatePathLength();
  908.     }
  910.     /**
  911.      * @internal
  912.      *
  913.      * @param bool|null $isUpdate
  914.      * @param array $params
  915.      *
  916.      * @throws \Exception
  917.      */
  918.     protected function update($isUpdate = null, $params = [])
  919.     {
  920.         $this->updateModificationInfos();
  922.         // save properties
  923.         $this->getProperties();
  924.         $this->getDao()->deleteAllProperties();
  926.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  927.             foreach ($this->getProperties() as $property) {
  928.                 if (!$property->getInherited()) {
  929.                     $property->setDao(null);
  930.                     $property->setCid($this->getId());
  931.                     $property->setCtype('object');
  932.                     $property->setCpath($this->getRealFullPath());
  933.                     $property->save();
  934.                 }
  935.             }
  936.         }
  938.         // save dependencies
  939.         $d = new Model\Dependency();
  940.         $d->setSourceType('object');
  941.         $d->setSourceId($this->getId());
  943.         foreach ($this->resolveDependencies() as $requirement) {
  944.             if ($requirement['id'] == $this->getId() && $requirement['type'] === 'object') {
  945.                 // dont't add a reference to yourself
  946.                 continue;
  947.             }
  949.             $d->addRequirement($requirement['id'], $requirement['type']);
  950.         }
  952.         $d->save();
  954.         //set object to registry
  955.         RuntimeCache::set(self::getCacheKey($this->getId()), $this);
  956.     }
  958.     /**
  959.      * {@inheritdoc}
  960.      */
  961.     public function clearDependentCache($additionalTags = [])
  962.     {
  963.         self::clearDependentCacheByObjectId($this->getId(), $additionalTags);
  964.     }
  966.     /**
  967.      * @internal
  968.      *
  969.      * @param int $objectId
  970.      * @param array $additionalTags
  971.      */
  972.     public static function clearDependentCacheByObjectId($objectId, $additionalTags = [])
  973.     {
  974.         if (!$objectId) {
  975.             throw new \Exception('object ID missing');
  976.         }
  978.         try {
  979.             $tags = ['object_' . $objectId, 'object_properties', 'output'];
  980.             $tags = array_merge($tags, $additionalTags);
  982.             Cache::clearTags($tags);
  983.         } catch (\Exception $e) {
  984.             Logger::crit((string) $e);
  985.         }
  986.     }
  988.     /**
  989.      * @internal
  990.      *
  991.      * @param int $index
  992.      */
  993.     public function saveIndex($index)
  994.     {
  995.         $this->getDao()->saveIndex($index);
  996.         $this->clearDependentCache();
  997.     }
  999.     /**
  1000.      * @return string
  1001.      */
  1002.     public function getFullPath()
  1003.     {
  1004.         $path = $this->getPath() . $this->getKey();
  1006.         return $path;
  1007.     }
  1009.     /**
  1010.      * @return string
  1011.      */
  1012.     public function getRealPath()
  1013.     {
  1014.         return $this->getPath();
  1015.     }
  1017.     /**
  1018.      * @return string
  1019.      */
  1020.     public function getRealFullPath()
  1021.     {
  1022.         return $this->getFullPath();
  1023.     }
  1025.     /**
  1026.      * @return int|null
  1027.      */
  1028.     public function getParentId()
  1029.     {
  1030.         $parentId = parent::getParentId();
  1032.         // fall back to parent if no ID is set but we have a parent object
  1033.         if (!$parentId && $this->parent) {
  1034.             return $this->parent->getId();
  1035.         }
  1037.         return $parentId;
  1038.     }
  1040.     /**
  1041.      * @return string
  1042.      */
  1043.     public function getType()
  1044.     {
  1045.         return $this->o_type;
  1046.     }
  1048.     /**
  1049.      * @return string|null
  1050.      */
  1051.     public function getKey()
  1052.     {
  1053.         return $this->o_key;
  1054.     }
  1056.     /**
  1057.      * @return int
  1058.      */
  1059.     public function getIndex()
  1060.     {
  1061.         return $this->o_index;
  1062.     }
  1064.     /**
  1065.      * @param int $parentId
  1066.      *
  1067.      * @return $this
  1068.      */
  1069.     public function setParentId($parentId)
  1070.     {
  1071.         $parentId = (int) $parentId;
  1072.         if ($parentId != $this->parentId) {
  1073.             $this->markFieldDirty('parentId');
  1074.         }
  1076.         parent::setParentId($parentId);
  1078.         $this->o_siblings = [];
  1079.         $this->o_hasSiblings = [];
  1081.         return $this;
  1082.     }
  1084.     /**
  1085.      * @param string $o_type
  1086.      *
  1087.      * @return $this
  1088.      */
  1089.     public function setType($o_type)
  1090.     {
  1091.         $this->o_type = $o_type;
  1093.         return $this;
  1094.     }
  1096.     /**
  1097.      * @param string $o_key
  1098.      *
  1099.      * @return $this
  1100.      */
  1101.     public function setKey($o_key)
  1102.     {
  1103.         $this->o_key = (string)$o_key;
  1105.         return $this;
  1106.     }
  1108.     /**
  1109.      * @param int $o_index
  1110.      *
  1111.      * @return $this
  1112.      */
  1113.     public function setIndex($o_index)
  1114.     {
  1115.         $this->o_index = (int) $o_index;
  1117.         return $this;
  1118.     }
  1120.     /**
  1121.      * @param string|null $childrenSortBy
  1122.      */
  1123.     public function setChildrenSortBy($childrenSortBy)
  1124.     {
  1125.         if ($this->o_childrenSortBy !== $childrenSortBy) {
  1126.             $this->o_children = [];
  1127.             $this->o_hasChildren = [];
  1128.         }
  1129.         $this->o_childrenSortBy = $childrenSortBy;
  1130.     }
  1132.     /**
  1133.      * @param DataObject[]|null $children
  1134.      * @param array $objectTypes
  1135.      * @param bool $includingUnpublished
  1136.      *
  1137.      * @return $this
  1138.      */
  1139.     public function setChildren($children, array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  1140.     {
  1141.         if ($children === null) {
  1142.             // unset all cached children
  1143.             $this->o_children = [];
  1144.             $this->o_hasChildren = [];
  1145.         } elseif (is_array($children)) {
  1146.             //default cache key
  1147.             $cacheKey = $this->getListingCacheKey([$objectTypes, $includingUnpublished]);
  1148.             $this->o_children[$cacheKey] = $children;
  1149.             $this->o_hasChildren[$cacheKey] = (bool) count($children);
  1150.         }
  1152.         return $this;
  1153.     }
  1155.     /**
  1156.      * @return self|null
  1157.      */
  1158.     public function getParent() /** : ?self **/
  1159.     {
  1160.         $parent = parent::getParent();
  1162.         return $parent instanceof AbstractObject ? $parent : null;
  1163.     }
  1165.     /**
  1166.      * @param self|null $parent
  1167.      *
  1168.      * @return $this
  1169.      */
  1170.     public function setParent($parent)
  1171.     {
  1172.         $newParentId = $parent instanceof self ? $parent->getId() : 0;
  1173.         $this->setParentId($newParentId);
  1174.         $this->parent = $parent;
  1176.         return $this;
  1177.     }
  1179.     /**
  1180.      * @return string
  1181.      */
  1182.     public function getChildrenSortBy()
  1183.     {
  1184.         return $this->o_childrenSortBy ?? self::OBJECT_CHILDREN_SORT_BY_DEFAULT;
  1185.     }
  1187.     /**
  1188.      * @param string $method
  1189.      * @param array $args
  1190.      *
  1191.      * @return mixed
  1192.      *
  1193.      * @throws \Exception
  1194.      */
  1195.     public function __call($method, $args)
  1196.     {
  1197.         // compatibility mode (they do not have any set_oXyz() methods anymore)
  1198.         if (preg_match('/^(get|set)o_/i', $method)) {
  1199.             $newMethod = preg_replace('/^(get|set)o_/i', '$1', $method);
  1200.             trigger_deprecation(
  1201.                 'pimcore/pimcore',
  1202.                 '10.6',
  1203.                 sprintf('using "%s" is deprecated, please use "%s" instead. using "%s" wont work in Pimcore 11.', $method, $newMethod, $method)
  1204.             );
  1205.             if (method_exists($this, $newMethod)) {
  1206.                 $r = call_user_func_array([$this, $newMethod], $args);
  1208.                 return $r;
  1209.             }
  1210.         }
  1212.         return parent::__call($method, $args);
  1213.     }
  1215.     /**
  1216.      * @return bool
  1217.      */
  1218.     public static function doNotRestoreKeyAndPath()
  1219.     {
  1220.         return self::$doNotRestoreKeyAndPath;
  1221.     }
  1223.     /**
  1224.      * @param bool $doNotRestoreKeyAndPath
  1225.      */
  1226.     public static function setDoNotRestoreKeyAndPath($doNotRestoreKeyAndPath)
  1227.     {
  1228.         self::$doNotRestoreKeyAndPath = $doNotRestoreKeyAndPath;
  1229.     }
  1231.     /**
  1232.      * @param string $fieldName
  1233.      * @param string|null $language
  1234.      *
  1235.      * @throws \Exception
  1236.      *
  1237.      * @return mixed
  1238.      */
  1239.     public function get($fieldName, $language = null)
  1240.     {
  1241.         if (!$fieldName) {
  1242.             throw new \Exception('Field name must not be empty.');
  1243.         }
  1245.         return $this->{'get'.ucfirst($fieldName)}($language);
  1246.     }
  1248.     /**
  1249.      * @param string $fieldName
  1250.      * @param mixed $value
  1251.      * @param string|null $language
  1252.      *
  1253.      * @throws \Exception
  1254.      *
  1255.      * @return mixed
  1256.      */
  1257.     public function set($fieldName, $value, $language = null)
  1258.     {
  1259.         if (!$fieldName) {
  1260.             throw new \Exception('Field name must not be empty.');
  1261.         }
  1263.         return $this->{'set'.ucfirst($fieldName)}($value, $language);
  1264.     }
  1266.     /**
  1267.      * @internal
  1268.      *
  1269.      * @return bool
  1270.      */
  1271.     public static function isDirtyDetectionDisabled()
  1272.     {
  1273.         return self::$disableDirtyDetection;
  1274.     }
  1276.     /**
  1277.      * @internal
  1278.      *
  1279.      * @param bool $disableDirtyDetection
  1280.      */
  1281.     public static function setDisableDirtyDetection(bool $disableDirtyDetection)
  1282.     {
  1283.         self::$disableDirtyDetection = $disableDirtyDetection;
  1284.     }
  1286.     /**
  1287.      * @internal
  1288.      */
  1289.     public static function disableDirtyDetection()
  1290.     {
  1291.         self::setDisableDirtyDetection(true);
  1292.     }
  1294.     /**
  1295.      * @internal
  1296.      */
  1297.     public static function enableDirtyDetection()
  1298.     {
  1299.         self::setDisableDirtyDetection(false);
  1300.     }
  1302.     /**
  1303.      * @internal
  1304.      *
  1305.      * @param array $args
  1306.      *
  1307.      * @return string
  1308.      */
  1309.     protected function getListingCacheKey(array $args = [])
  1310.     {
  1311.         $objectTypes = $args[0] ?? [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER];
  1312.         $includingUnpublished = (bool)($args[1] ?? false);
  1314.         if (is_array($objectTypes)) {
  1315.             $objectTypes = implode('_', $objectTypes);
  1316.         }
  1318.         $cacheKey = $objectTypes . (!empty($includingUnpublished) ? '_' : '') . (string)$includingUnpublished;
  1320.         return $cacheKey;
  1321.     }
  1323.     /**
  1324.      * @param string | null $o_reverseSort
  1325.      *
  1326.      * @return AbstractObject
  1327.      */
  1328.     public function setChildrenSortOrder(?string $o_reverseSort): Element\ElementInterface
  1329.     {
  1330.         $this->o_childrenSortOrder = $o_reverseSort;
  1332.         return $this;
  1333.     }
  1335.     /**
  1336.      * @return string
  1337.      */
  1338.     public function getChildrenSortOrder(): string
  1339.     {
  1340.         return $this->o_childrenSortOrder ?? self::OBJECT_CHILDREN_SORT_ORDER_DEFAULT;
  1341.     }
  1343.     /**
  1344.      * load lazy loaded fields before cloning
  1345.      */
  1346.     public function __clone()
  1347.     {
  1348.         parent::__clone();
  1350.         // renew references when cloning
  1351.         foreach (['id', 'path', 'creationDate', 'userOwner', 'versionCount', 'modificationDate', 'locked', 'parent', 'properties', 'userModification', 'parentId'] as $referenceField) {
  1352.             $oldValue = $this->$referenceField;
  1353.             unset($this->$referenceField);
  1354.             $this->$referenceField = $oldValue;
  1355.             $this->{'o_'.$referenceField} = &$this->$referenceField;
  1356.         }
  1358.         $this->o_parent = null;
  1359.         // note that o_children is currently needed for the recycle bin
  1360.         $this->o_hasSiblings = [];
  1361.         $this->o_siblings = [];
  1362.     }
  1364.     /**
  1365.      * @param string $method
  1366.      * @param array $arguments
  1367.      *
  1368.      * @return mixed
  1369.      *
  1370.      * @throws \Exception
  1371.      */
  1372.     public static function __callStatic($method, $arguments)
  1373.     {
  1374.         $propertyName = lcfirst(preg_replace('/^getBy/i', '', $method));
  1376.         $realPropertyName = 'o_'.$propertyName;
  1378.         $db = \Pimcore\Db::get();
  1380.         if (in_array(strtolower($realPropertyName), self::$objectColumns)) {
  1381.             $arguments = array_pad($arguments, 4, 0);
  1382.             [$value, $limit, $offset, $objectTypes] = $arguments;
  1384.             $defaultCondition = $realPropertyName.' = '.Db::get()->quote($value).' ';
  1386.             $listConfig = [
  1387.                 'condition' => $defaultCondition,
  1388.             ];
  1390.             if (!is_array($limit)) {
  1391.                 if ($limit) {
  1392.                     $listConfig['limit'] = $limit;
  1393.                 }
  1394.                 if ($offset) {
  1395.                     $listConfig['offset'] = $offset;
  1396.                 }
  1397.             } else {
  1398.                 $listConfig = array_merge($listConfig, $limit);
  1399.                 $limitCondition = $limit['condition'] ?? '';
  1400.                 $listConfig['condition'] = $defaultCondition.$limitCondition;
  1401.             }
  1403.             $list = static::makeList($listConfig, $objectTypes);
  1405.             if (isset($listConfig['limit']) && $listConfig['limit'] == 1) {
  1406.                 $elements = $list->getObjects();
  1408.                 return isset($elements[0]) ? $elements[0] : null;
  1409.             }
  1411.             return $list;
  1412.         }
  1414.         // there is no property for the called method, so throw an exception
  1415.         Logger::error('Class: DataObject\\AbstractObject => call to undefined static method ' . $method);
  1417.         throw new \Exception('Call to undefined static method ' . $method . ' in class DataObject\\AbstractObject');
  1418.     }
  1420.     /**
  1421.      * @param  array  $listConfig
  1422.      * @param  mixed $objectTypes
  1423.      *
  1424.      * @return Listing
  1425.      *
  1426.      * @throws \Exception
  1427.      */
  1428.     protected static function makeList(array $listConfig, mixed $objectTypes): Listing
  1429.     {
  1430.         $list = static::getList($listConfig);
  1432.         // Check if variants, in addition to objects, to be fetched
  1433.         if (!empty($objectTypes)) {
  1434.             if (\array_diff($objectTypes, [static::OBJECT_TYPE_VARIANT, static::OBJECT_TYPE_OBJECT])) {
  1435.                 Logger::error('Class: DataObject\\AbstractObject => Unsupported object type in array ' . implode(',', $objectTypes));
  1437.                 throw new \Exception('Unsupported object type in array [' . implode(',', $objectTypes) . '] in class DataObject\\AbstractObject');
  1438.             }
  1440.             $list->setObjectTypes($objectTypes);
  1441.         }
  1443.         return $list;
  1444.     }
  1446.     public function __wakeup()
  1447.     {
  1448.         $propertyMappings = [
  1449.             'o_id' => 'id',
  1450.             'o_path' => 'path',
  1451.             'o_creationDate' => 'creationDate',
  1452.             'o_userOwner' => 'userOwner',
  1453.             'o_versionCount' => 'versionCount',
  1454.             'o_locked' => 'locked',
  1455.             'o_parent' => 'parent',
  1456.             'o_properties' => 'properties',
  1457.             'o_userModification' => 'userModification',
  1458.             'o_modificationDate' => 'modificationDate',
  1459.             'o_parentId' => 'parentId',
  1460.         ];
  1462.         foreach ($propertyMappings as $oldProperty => $newProperty) {
  1463.             if ($this->$newProperty === null) {
  1464.                 $this->$newProperty = $this->$oldProperty;
  1465.                 $this->$oldProperty = & $this->$newProperty;
  1466.             }
  1467.         }
  1469.         parent::__wakeup();
  1470.     }
  1471. }