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

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 $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.         return in_array(static::class, [Concrete::class, __CLASS__], true) || $object instanceof static;
  520.     }
  522.     /**
  523.      * @param array $objectTypes
  524.      * @param bool $includingUnpublished
  525.      *
  526.      * @return DataObject[]
  527.      */
  528.     public function getChildren(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  529.     {
  530.         $cacheKey = $this->getListingCacheKey(func_get_args());
  532.         if (!isset($this->o_children[$cacheKey])) {
  533.             if ($this->getId()) {
  534.                 $list = new Listing();
  535.                 $list->setUnpublished($includingUnpublished);
  536.                 $list->setCondition('o_parentId = ?', $this->getId());
  537.                 $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  538.                 $list->setOrder($this->getChildrenSortOrder());
  539.                 $list->setObjectTypes($objectTypes);
  540.                 $this->o_children[$cacheKey] = $list->load();
  541.                 $this->o_hasChildren[$cacheKey] = (bool) count($this->o_children[$cacheKey]);
  542.             } else {
  543.                 $this->o_children[$cacheKey] = [];
  544.                 $this->o_hasChildren[$cacheKey] = false;
  545.             }
  546.         }
  548.         return $this->o_children[$cacheKey];
  549.     }
  551.     /**
  552.      * Quick test if there are children
  553.      *
  554.      * @param array $objectTypes
  555.      * @param bool|null $includingUnpublished
  556.      *
  557.      * @return bool
  558.      */
  559.     public function hasChildren($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  560.     {
  561.         $cacheKey = $this->getListingCacheKey(func_get_args());
  563.         if (isset($this->o_hasChildren[$cacheKey])) {
  564.             return $this->o_hasChildren[$cacheKey];
  565.         }
  567.         return $this->o_hasChildren[$cacheKey] = $this->getDao()->hasChildren($objectTypes, $includingUnpublished);
  568.     }
  570.     /**
  571.      * Get a list of the sibling documents
  572.      *
  573.      * @param array $objectTypes
  574.      * @param bool $includingUnpublished
  575.      *
  576.      * @return array
  577.      */
  578.     public function getSiblings(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  579.     {
  580.         $cacheKey = $this->getListingCacheKey(func_get_args());
  582.         if (!isset($this->o_siblings[$cacheKey])) {
  583.             if ($this->getParentId()) {
  584.                 $list = new Listing();
  585.                 $list->setUnpublished($includingUnpublished);
  586.                 $list->addConditionParam('o_parentId = ?', $this->getParentId());
  587.                 if ($this->getId()) {
  588.                     $list->addConditionParam('o_id != ?', $this->getId());
  589.                 }
  590.                 $list->setOrderKey('o_key');
  591.                 $list->setObjectTypes($objectTypes);
  592.                 $list->setOrder('asc');
  593.                 $this->o_siblings[$cacheKey] = $list->load();
  594.                 $this->o_hasSiblings[$cacheKey] = (bool) count($this->o_siblings[$cacheKey]);
  595.             } else {
  596.                 $this->o_siblings[$cacheKey] = [];
  597.                 $this->o_hasSiblings[$cacheKey] = false;
  598.             }
  599.         }
  601.         return $this->o_siblings[$cacheKey];
  602.     }
  604.     /**
  605.      * Returns true if the object has at least one sibling
  606.      *
  607.      * @param array $objectTypes
  608.      * @param bool|null $includingUnpublished
  609.      *
  610.      * @return bool
  611.      */
  612.     public function hasSiblings($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  613.     {
  614.         $cacheKey = $this->getListingCacheKey(func_get_args());
  616.         if (isset($this->o_hasSiblings[$cacheKey])) {
  617.             return $this->o_hasSiblings[$cacheKey];
  618.         }
  620.         return $this->o_hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($objectTypes, $includingUnpublished);
  621.     }
  623.     /**
  624.      * @internal
  625.      *
  626.      * @throws \Exception
  627.      */
  628.     protected function doDelete()
  629.     {
  630.         // delete children
  631.         $children = $this->getChildren(self::$types, true);
  632.         if (count($children) > 0) {
  633.             foreach ($children as $child) {
  634.                 $child->delete();
  635.             }
  636.         }
  638.         // remove dependencies
  639.         $d = new Model\Dependency;
  640.         $d->cleanAllForElement($this);
  642.         // remove all properties
  643.         $this->getDao()->deleteAllProperties();
  644.     }
  646.     /**
  647.      * @throws \Exception
  648.      */
  649.     public function delete()
  650.     {
  651.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::PRE_DELETE);
  653.         $this->beginTransaction();
  655.         try {
  656.             $this->doDelete();
  657.             $this->getDao()->delete();
  659.             $this->commit();
  661.             //clear parent data from registry
  662.             $parentCacheKey = self::getCacheKey($this->getParentId());
  663.             if (RuntimeCache::isRegistered($parentCacheKey)) {
  664.                 /** @var AbstractObject $parent * */
  665.                 $parent = RuntimeCache::get($parentCacheKey);
  666.                 if ($parent instanceof self) {
  667.                     $parent->setChildren(null);
  668.                 }
  669.             }
  670.         } catch (\Exception $e) {
  671.             try {
  672.                 $this->rollBack();
  673.             } catch (\Exception $er) {
  674.                 // PDO adapter throws exceptions if rollback fails
  675.                 Logger::info((string) $er);
  676.             }
  678.             $failureEvent = new DataObjectEvent($this);
  679.             $failureEvent->setArgument('exception', $e);
  680.             $this->dispatchEvent($failureEvent, DataObjectEvents::POST_DELETE_FAILURE);
  682.             Logger::crit((string) $e);
  684.             throw $e;
  685.         }
  687.         // empty object cache
  688.         $this->clearDependentCache();
  690.         //clear object from registry
  691.         RuntimeCache::set(self::getCacheKey($this->getId()), null);
  693.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::POST_DELETE);
  694.     }
  696.     /**
  697.      * @return $this
  698.      *
  699.      * @throws \Exception
  700.      */
  701.     public function save()
  702.     {
  703.         // additional parameters (e.g. "versionNote" for the version note)
  704.         $params = [];
  705.         if (func_num_args() && is_array(func_get_arg(0))) {
  706.             $params = func_get_arg(0);
  707.         }
  709.         $isUpdate = false;
  710.         $differentOldPath = null;
  712.         try {
  713.             $isDirtyDetectionDisabled = self::isDirtyDetectionDisabled();
  714.             $preEvent = new DataObjectEvent($this, $params);
  715.             if ($this->getId()) {
  716.                 $isUpdate = true;
  717.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_UPDATE);
  718.             } else {
  719.                 self::disableDirtyDetection();
  720.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_ADD);
  721.             }
  723.             $params = $preEvent->getArguments();
  725.             $this->correctPath();
  727.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  728.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  729.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  730.             $maxRetries = 5;
  731.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  732.                 // be sure that unpublished objects in relations are saved also in frontend mode, eg. in importers, ...
  733.                 $hideUnpublishedBackup = self::getHideUnpublished();
  734.                 self::setHideUnpublished(false);
  736.                 $this->beginTransaction();
  738.                 try {
  739.                     if (!in_array($this->getType(), self::$types)) {
  740.                         throw new \Exception('invalid object type given: [' . $this->getType() . ']');
  741.                     }
  743.                     if (!$isUpdate) {
  744.                         $this->getDao()->create();
  745.                     }
  747.                     // get the old path from the database before the update is done
  748.                     $oldPath = null;
  749.                     if ($isUpdate) {
  750.                         $oldPath = $this->getDao()->getCurrentFullPath();
  751.                     }
  753.                     // if the old path is different from the new path, update all children
  754.                     // we need to do the update of the children's path before $this->update() because the
  755.                     // inheritance helper needs the correct paths of the children in InheritanceHelper::buildTree()
  756.                     $updatedChildren = [];
  757.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  758.                         $differentOldPath = $oldPath;
  759.                         $this->getDao()->updateWorkspaces();
  760.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  761.                     }
  763.                     $this->update($isUpdate, $params);
  765.                     self::setHideUnpublished($hideUnpublishedBackup);
  767.                     $this->commit();
  769.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  770.                 } catch (\Exception $e) {
  771.                     try {
  772.                         $this->rollBack();
  773.                     } catch (\Exception $er) {
  774.                         // PDO adapter throws exceptions if rollback fails
  775.                         Logger::info((string) $er);
  776.                     }
  778.                     // set "HideUnpublished" back to the value it was originally
  779.                     self::setHideUnpublished($hideUnpublishedBackup);
  781.                     if ($e instanceof UniqueConstraintViolationException) {
  782.                         throw new Element\ValidationException('unique constraint violation', 0, $e);
  783.                     }
  785.                     if ($e instanceof RetryableException) {
  786.                         // we try to start the transaction $maxRetries times again (deadlocks, ...)
  787.                         if ($retries < ($maxRetries - 1)) {
  788.                             $run = $retries + 1;
  789.                             $waitTime = random_int(1, 5) * 100000; // microseconds
  790.                             Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  792.                             usleep($waitTime); // wait specified time until we restart the transaction
  793.                         } else {
  794.                             // if the transaction still fail after $maxRetries retries, we throw out the exception
  795.                             Logger::error('Finally giving up restarting the same transaction again and again, last message: ' . $e->getMessage());
  797.                             throw $e;
  798.                         }
  799.                     } else {
  800.                         throw $e;
  801.                     }
  802.                 }
  803.             }
  805.             $additionalTags = [];
  806.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  807.                 foreach ($updatedChildren as $objectId) {
  808.                     $tag = 'object_' . $objectId;
  809.                     $additionalTags[] = $tag;
  811.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  812.                     RuntimeCache::set($tag, null);
  813.                 }
  814.             }
  815.             $this->clearDependentCache($additionalTags);
  817.             $postEvent = new DataObjectEvent($this, $params);
  818.             if ($isUpdate) {
  819.                 if ($differentOldPath) {
  820.                     $postEvent->setArgument('oldPath', $differentOldPath);
  821.                 }
  822.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_UPDATE);
  823.             } else {
  824.                 self::setDisableDirtyDetection($isDirtyDetectionDisabled);
  825.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_ADD);
  826.             }
  828.             return $this;
  829.         } catch (\Exception $e) {
  830.             $failureEvent = new DataObjectEvent($this, $params);
  831.             $failureEvent->setArgument('exception', $e);
  832.             if ($isUpdate) {
  833.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_UPDATE_FAILURE);
  834.             } else {
  835.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_ADD_FAILURE);
  836.             }
  838.             throw $e;
  839.         }
  840.     }
  842.     /**
  843.      * @internal
  844.      *
  845.      * @throws \Exception|DuplicateFullPathException
  846.      */
  847.     protected function correctPath()
  848.     {
  849.         // set path
  850.         if ($this->getId() != 1) { // not for the root node
  851.             if (!Element\Service::isValidKey($this->getKey(), 'object')) {
  852.                 throw new \Exception('invalid key for object with id [ '.$this->getId().' ] key is: [' . $this->getKey() . ']');
  853.             }
  855.             if ($this->getParentId() == $this->getId()) {
  856.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  857.             }
  859.             $parent = DataObject::getById($this->getParentId());
  861.             if ($parent) {
  862.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  863.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  864.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath().'/'));
  865.             } else {
  866.                 trigger_deprecation(
  867.                     'pimcore/pimcore',
  868.                     '10.5',
  869.                     'Fallback for parentId will be removed in Pimcore 11.',
  870.                 );
  871.                 // parent document doesn't exist anymore, set the parent to to root
  872.                 $this->setParentId(1);
  873.                 $this->setPath('/');
  874.             }
  876.             if (strlen($this->getKey()) < 1) {
  877.                 throw new \Exception('DataObject requires key');
  878.             }
  879.         } elseif ($this->getId() == 1) {
  880.             // some data in root node should always be the same
  881.             $this->setParentId(0);
  882.             $this->setPath('/');
  883.             $this->setKey('');
  884.             $this->setType(DataObject::OBJECT_TYPE_FOLDER);
  885.         }
  887.         if (Service::pathExists($this->getRealFullPath())) {
  888.             $duplicate = DataObject::getByPath($this->getRealFullPath());
  889.             if ($duplicate instanceof self && $duplicate->getId() != $this->getId()) {
  890.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ '.$this->getRealFullPath().' ] - cannot save object');
  891.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  893.                 throw $duplicateFullPathException;
  894.             }
  895.         }
  897.         $this->validatePathLength();
  898.     }
  900.     /**
  901.      * @internal
  902.      *
  903.      * @param bool|null $isUpdate
  904.      * @param array $params
  905.      *
  906.      * @throws \Exception
  907.      */
  908.     protected function update($isUpdate = null, $params = [])
  909.     {
  910.         $this->updateModificationInfos();
  912.         // save properties
  913.         $this->getProperties();
  914.         $this->getDao()->deleteAllProperties();
  916.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  917.             foreach ($this->getProperties() as $property) {
  918.                 if (!$property->getInherited()) {
  919.                     $property->setDao(null);
  920.                     $property->setCid($this->getId());
  921.                     $property->setCtype('object');
  922.                     $property->setCpath($this->getRealFullPath());
  923.                     $property->save();
  924.                 }
  925.             }
  926.         }
  928.         // save dependencies
  929.         $d = new Model\Dependency();
  930.         $d->setSourceType('object');
  931.         $d->setSourceId($this->getId());
  933.         foreach ($this->resolveDependencies() as $requirement) {
  934.             if ($requirement['id'] == $this->getId() && $requirement['type'] === 'object') {
  935.                 // dont't add a reference to yourself
  936.                 continue;
  937.             }
  939.             $d->addRequirement($requirement['id'], $requirement['type']);
  940.         }
  942.         $d->save();
  944.         //set object to registry
  945.         RuntimeCache::set(self::getCacheKey($this->getId()), $this);
  946.     }
  948.     /**
  949.      * {@inheritdoc}
  950.      */
  951.     public function clearDependentCache($additionalTags = [])
  952.     {
  953.         self::clearDependentCacheByObjectId($this->getId(), $additionalTags);
  954.     }
  956.     /**
  957.      * @internal
  958.      *
  959.      * @param int $objectId
  960.      * @param array $additionalTags
  961.      */
  962.     public static function clearDependentCacheByObjectId($objectId, $additionalTags = [])
  963.     {
  964.         if (!$objectId) {
  965.             throw new \Exception('object ID missing');
  966.         }
  968.         try {
  969.             $tags = ['object_' . $objectId, 'object_properties', 'output'];
  970.             $tags = array_merge($tags, $additionalTags);
  972.             Cache::clearTags($tags);
  973.         } catch (\Exception $e) {
  974.             Logger::crit((string) $e);
  975.         }
  976.     }
  978.     /**
  979.      * @internal
  980.      *
  981.      * @param int $index
  982.      */
  983.     public function saveIndex($index)
  984.     {
  985.         $this->getDao()->saveIndex($index);
  986.         $this->clearDependentCache();
  987.     }
  989.     /**
  990.      * @return string
  991.      */
  992.     public function getFullPath()
  993.     {
  994.         $path = $this->getPath() . $this->getKey();
  996.         return $path;
  997.     }
  999.     /**
  1000.      * @return string
  1001.      */
  1002.     public function getRealPath()
  1003.     {
  1004.         return $this->getPath();
  1005.     }
  1007.     /**
  1008.      * @return string
  1009.      */
  1010.     public function getRealFullPath()
  1011.     {
  1012.         return $this->getFullPath();
  1013.     }
  1015.     /**
  1016.      * @return int|null
  1017.      */
  1018.     public function getParentId()
  1019.     {
  1020.         $parentId = parent::getParentId();
  1022.         // fall back to parent if no ID is set but we have a parent object
  1023.         if (!$parentId && $this->parent) {
  1024.             return $this->parent->getId();
  1025.         }
  1027.         return $parentId;
  1028.     }
  1030.     /**
  1031.      * @return string
  1032.      */
  1033.     public function getType()
  1034.     {
  1035.         return $this->o_type;
  1036.     }
  1038.     /**
  1039.      * @return string|null
  1040.      */
  1041.     public function getKey()
  1042.     {
  1043.         return $this->o_key;
  1044.     }
  1046.     /**
  1047.      * @return int
  1048.      */
  1049.     public function getIndex()
  1050.     {
  1051.         return $this->o_index;
  1052.     }
  1054.     /**
  1055.      * @param int $parentId
  1056.      *
  1057.      * @return $this
  1058.      */
  1059.     public function setParentId($parentId)
  1060.     {
  1061.         $parentId = (int) $parentId;
  1062.         if ($parentId != $this->parentId) {
  1063.             $this->markFieldDirty('parentId');
  1064.         }
  1066.         parent::setParentId($parentId);
  1068.         $this->o_siblings = [];
  1069.         $this->o_hasSiblings = [];
  1071.         return $this;
  1072.     }
  1074.     /**
  1075.      * @param string $o_type
  1076.      *
  1077.      * @return $this
  1078.      */
  1079.     public function setType($o_type)
  1080.     {
  1081.         $this->o_type = $o_type;
  1083.         return $this;
  1084.     }
  1086.     /**
  1087.      * @param string $o_key
  1088.      *
  1089.      * @return $this
  1090.      */
  1091.     public function setKey($o_key)
  1092.     {
  1093.         $this->o_key = (string)$o_key;
  1095.         return $this;
  1096.     }
  1098.     /**
  1099.      * @param int $o_index
  1100.      *
  1101.      * @return $this
  1102.      */
  1103.     public function setIndex($o_index)
  1104.     {
  1105.         $this->o_index = (int) $o_index;
  1107.         return $this;
  1108.     }
  1110.     /**
  1111.      * @param string|null $childrenSortBy
  1112.      */
  1113.     public function setChildrenSortBy($childrenSortBy)
  1114.     {
  1115.         if ($this->o_childrenSortBy !== $childrenSortBy) {
  1116.             $this->o_children = [];
  1117.             $this->o_hasChildren = [];
  1118.         }
  1119.         $this->o_childrenSortBy = $childrenSortBy;
  1120.     }
  1122.     /**
  1123.      * @param DataObject[]|null $children
  1124.      * @param array $objectTypes
  1125.      * @param bool $includingUnpublished
  1126.      *
  1127.      * @return $this
  1128.      */
  1129.     public function setChildren($children, array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  1130.     {
  1131.         if ($children === null) {
  1132.             // unset all cached children
  1133.             $this->o_children = [];
  1134.             $this->o_hasChildren = [];
  1135.         } elseif (is_array($children)) {
  1136.             //default cache key
  1137.             $cacheKey = $this->getListingCacheKey([$objectTypes, $includingUnpublished]);
  1138.             $this->o_children[$cacheKey] = $children;
  1139.             $this->o_hasChildren[$cacheKey] = (bool) count($children);
  1140.         }
  1142.         return $this;
  1143.     }
  1145.     /**
  1146.      * @return self|null
  1147.      */
  1148.     public function getParent() /** : ?self **/
  1149.     {
  1150.         $parent = parent::getParent();
  1152.         return $parent instanceof AbstractObject ? $parent : null;
  1153.     }
  1155.     /**
  1156.      * @param self|null $parent
  1157.      *
  1158.      * @return $this
  1159.      */
  1160.     public function setParent($parent)
  1161.     {
  1162.         $newParentId = $parent instanceof self ? $parent->getId() : 0;
  1163.         $this->setParentId($newParentId);
  1164.         $this->parent = $parent;
  1166.         return $this;
  1167.     }
  1169.     /**
  1170.      * @return string
  1171.      */
  1172.     public function getChildrenSortBy()
  1173.     {
  1174.         return $this->o_childrenSortBy ?? self::OBJECT_CHILDREN_SORT_BY_DEFAULT;
  1175.     }
  1177.     /**
  1178.      * @param string $method
  1179.      * @param array $args
  1180.      *
  1181.      * @return mixed
  1182.      *
  1183.      * @throws \Exception
  1184.      */
  1185.     public function __call($method, $args)
  1186.     {
  1187.         // compatibility mode (they do not have any set_oXyz() methods anymore)
  1188.         if (preg_match('/^(get|set)o_/i', $method)) {
  1189.             $newMethod = preg_replace('/^(get|set)o_/i', '$1', $method);
  1190.             if (method_exists($this, $newMethod)) {
  1191.                 $r = call_user_func_array([$this, $newMethod], $args);
  1193.                 return $r;
  1194.             }
  1195.         }
  1197.         return parent::__call($method, $args);
  1198.     }
  1200.     /**
  1201.      * @return bool
  1202.      */
  1203.     public static function doNotRestoreKeyAndPath()
  1204.     {
  1205.         return self::$doNotRestoreKeyAndPath;
  1206.     }
  1208.     /**
  1209.      * @param bool $doNotRestoreKeyAndPath
  1210.      */
  1211.     public static function setDoNotRestoreKeyAndPath($doNotRestoreKeyAndPath)
  1212.     {
  1213.         self::$doNotRestoreKeyAndPath = $doNotRestoreKeyAndPath;
  1214.     }
  1216.     /**
  1217.      * @param string $fieldName
  1218.      * @param string|null $language
  1219.      *
  1220.      * @throws \Exception
  1221.      *
  1222.      * @return mixed
  1223.      */
  1224.     public function get($fieldName, $language = null)
  1225.     {
  1226.         if (!$fieldName) {
  1227.             throw new \Exception('Field name must not be empty.');
  1228.         }
  1230.         return $this->{'get'.ucfirst($fieldName)}($language);
  1231.     }
  1233.     /**
  1234.      * @param string $fieldName
  1235.      * @param mixed $value
  1236.      * @param string|null $language
  1237.      *
  1238.      * @throws \Exception
  1239.      *
  1240.      * @return mixed
  1241.      */
  1242.     public function set($fieldName, $value, $language = null)
  1243.     {
  1244.         if (!$fieldName) {
  1245.             throw new \Exception('Field name must not be empty.');
  1246.         }
  1248.         return $this->{'set'.ucfirst($fieldName)}($value, $language);
  1249.     }
  1251.     /**
  1252.      * @internal
  1253.      *
  1254.      * @return bool
  1255.      */
  1256.     public static function isDirtyDetectionDisabled()
  1257.     {
  1258.         return self::$disableDirtyDetection;
  1259.     }
  1261.     /**
  1262.      * @internal
  1263.      *
  1264.      * @param bool $disableDirtyDetection
  1265.      */
  1266.     public static function setDisableDirtyDetection(bool $disableDirtyDetection)
  1267.     {
  1268.         self::$disableDirtyDetection = $disableDirtyDetection;
  1269.     }
  1271.     /**
  1272.      * @internal
  1273.      */
  1274.     public static function disableDirtyDetection()
  1275.     {
  1276.         self::setDisableDirtyDetection(true);
  1277.     }
  1279.     /**
  1280.      * @internal
  1281.      */
  1282.     public static function enableDirtyDetection()
  1283.     {
  1284.         self::setDisableDirtyDetection(false);
  1285.     }
  1287.     /**
  1288.      * @internal
  1289.      *
  1290.      * @param array $args
  1291.      *
  1292.      * @return string
  1293.      */
  1294.     protected function getListingCacheKey(array $args = [])
  1295.     {
  1296.         $objectTypes = $args[0] ?? [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER];
  1297.         $includingUnpublished = (bool)($args[1] ?? false);
  1299.         if (is_array($objectTypes)) {
  1300.             $objectTypes = implode('_', $objectTypes);
  1301.         }
  1303.         $cacheKey = $objectTypes . (!empty($includingUnpublished) ? '_' : '') . (string)$includingUnpublished;
  1305.         return $cacheKey;
  1306.     }
  1308.     /**
  1309.      * @param string | null $o_reverseSort
  1310.      *
  1311.      * @return AbstractObject
  1312.      */
  1313.     public function setChildrenSortOrder(?string $o_reverseSort): Element\ElementInterface
  1314.     {
  1315.         $this->o_childrenSortOrder = $o_reverseSort;
  1317.         return $this;
  1318.     }
  1320.     /**
  1321.      * @return string
  1322.      */
  1323.     public function getChildrenSortOrder(): string
  1324.     {
  1325.         return $this->o_childrenSortOrder ?? self::OBJECT_CHILDREN_SORT_ORDER_DEFAULT;
  1326.     }
  1328.     /**
  1329.      * load lazy loaded fields before cloning
  1330.      */
  1331.     public function __clone()
  1332.     {
  1333.         parent::__clone();
  1335.         // renew references when cloning
  1336.         foreach (['id', 'path', 'creationDate', 'userOwner', 'versionCount', 'modificationDate', 'locked', 'parent', 'properties', 'userModification', 'parentId'] as $referenceField) {
  1337.             $oldValue = $this->$referenceField;
  1338.             unset($this->$referenceField);
  1339.             $this->$referenceField = $oldValue;
  1340.             $this->{'o_'.$referenceField} = &$this->$referenceField;
  1341.         }
  1343.         $this->o_parent = null;
  1344.         // note that o_children is currently needed for the recycle bin
  1345.         $this->o_hasSiblings = [];
  1346.         $this->o_siblings = [];
  1347.     }
  1349.     /**
  1350.      * @param string $method
  1351.      * @param array $arguments
  1352.      *
  1353.      * @return mixed|Listing|null
  1354.      *
  1355.      * @throws \Exception
  1356.      */
  1357.     public static function __callStatic($method, $arguments)
  1358.     {
  1359.         $propertyName = lcfirst(preg_replace('/^getBy/i', '', $method));
  1361.         $realPropertyName = 'o_'.$propertyName;
  1363.         $db = \Pimcore\Db::get();
  1365.         if (in_array(strtolower($realPropertyName), self::$objectColumns)) {
  1366.             $arguments = array_pad($arguments, 4, 0);
  1367.             [$value, $limit, $offset, $objectTypes] = $arguments;
  1369.             $defaultCondition = $realPropertyName.' = '.Db::get()->quote($value).' ';
  1371.             $listConfig = [
  1372.                 'condition' => $defaultCondition,
  1373.             ];
  1375.             if (!is_array($limit)) {
  1376.                 if ($limit) {
  1377.                     $listConfig['limit'] = $limit;
  1378.                 }
  1379.                 if ($offset) {
  1380.                     $listConfig['offset'] = $offset;
  1381.                 }
  1382.             } else {
  1383.                 $listConfig = array_merge($listConfig, $limit);
  1384.                 $limitCondition = $limit['condition'] ?? '';
  1385.                 $listConfig['condition'] = $defaultCondition.$limitCondition;
  1386.             }
  1388.             $list = static::makeList($listConfig, $objectTypes);
  1390.             if (isset($listConfig['limit']) && $listConfig['limit'] == 1) {
  1391.                 $elements = $list->getObjects();
  1393.                 return isset($elements[0]) ? $elements[0] : null;
  1394.             }
  1396.             return $list;
  1397.         }
  1399.         // there is no property for the called method, so throw an exception
  1400.         Logger::error('Class: DataObject\\AbstractObject => call to undefined static method ' . $method);
  1402.         throw new \Exception('Call to undefined static method ' . $method . ' in class DataObject\\AbstractObject');
  1403.     }
  1405.     /**
  1406.      * @param  array  $listConfig
  1407.      * @param  mixed $objectTypes
  1408.      *
  1409.      * @return Listing
  1410.      *
  1411.      * @throws \Exception
  1412.      */
  1413.     protected static function makeList(array $listConfig, mixed $objectTypes): Listing
  1414.     {
  1415.         $list = static::getList($listConfig);
  1417.         // Check if variants, in addition to objects, to be fetched
  1418.         if (!empty($objectTypes)) {
  1419.             if (\array_diff($objectTypes, [static::OBJECT_TYPE_VARIANT, static::OBJECT_TYPE_OBJECT])) {
  1420.                 Logger::error('Class: DataObject\\AbstractObject => Unsupported object type in array ' . implode(',', $objectTypes));
  1422.                 throw new \Exception('Unsupported object type in array [' . implode(',', $objectTypes) . '] in class DataObject\\AbstractObject');
  1423.             }
  1425.             $list->setObjectTypes($objectTypes);
  1426.         }
  1428.         return $list;
  1429.     }
  1431.     public function __wakeup()
  1432.     {
  1433.         $propertyMappings = [
  1434.             'o_id' => 'id',
  1435.             'o_path' => 'path',
  1436.             'o_creationDate' => 'creationDate',
  1437.             'o_userOwner' => 'userOwner',
  1438.             'o_versionCount' => 'versionCount',
  1439.             'o_locked' => 'locked',
  1440.             'o_parent' => 'parent',
  1441.             'o_properties' => 'properties',
  1442.             'o_userModification' => 'userModification',
  1443.             'o_modificationDate' => 'modificationDate',
  1444.             'o_parentId' => 'parentId',
  1445.         ];
  1447.         foreach ($propertyMappings as $oldProperty => $newProperty) {
  1448.             if ($this->$newProperty === null) {
  1449.                 $this->$newProperty = $this->$oldProperty;
  1450.                 $this->$oldProperty = & $this->$newProperty;
  1451.             }
  1452.         }
  1454.         parent::__wakeup();
  1455.     }
  1456. }