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

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\Runtime;
  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.      * @internal
  55.      *
  56.      * @var bool
  57.      */
  58.     public static $doNotRestoreKeyAndPath = false;
  60.     /**
  61.      * possible types of a document
  62.      *
  63.      * @var array
  64.      */
  65.     public static $types = [self::OBJECT_TYPE_FOLDER, self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_VARIANT];
  67.     /**
  68.      * @var bool
  69.      */
  70.     private static $hideUnpublished = false;
  72.     /**
  73.      * @var bool
  74.      */
  75.     private static $getInheritedValues = false;
  77.     /**
  78.      * @internal
  79.      *
  80.      * @var bool
  81.      */
  82.     protected static $disableDirtyDetection = false;
  84.     /**
  85.      * @internal
  86.      *
  87.      * @var string[]
  88.      */
  89.     protected static $objectColumns = ['o_id', 'o_parentid', 'o_type', 'o_key', 'o_classid', 'o_classname', 'o_path'];
  91.     /**
  92.      * @internal
  93.      *
  94.      * @var int|null
  95.      */
  96.     protected $o_id;
  98.     /**
  99.      * @internal
  100.      *
  101.      * @var int|null
  102.      */
  103.     protected $o_parentId;
  105.     /**
  106.      * @internal
  107.      *
  108.      * @var self|null
  109.      */
  110.     protected $o_parent;
  112.     /**
  113.      * @internal
  114.      *
  115.      * @var string
  116.      */
  117.     protected $o_type = 'object';
  119.     /**
  120.      * @internal
  121.      *
  122.      * @var string|null
  123.      */
  124.     protected $o_key;
  126.     /**
  127.      * @internal
  128.      *
  129.      * @var string|null
  130.      */
  131.     protected $o_path;
  133.     /**
  134.      * @internal
  135.      *
  136.      * @var int
  137.      */
  138.     protected $o_index = 0;
  140.     /**
  141.      * @internal
  142.      *
  143.      * @var int|null
  144.      */
  145.     protected $o_creationDate;
  147.     /**
  148.      * @internal
  149.      *
  150.      * @var int|null
  151.      */
  152.     protected $o_modificationDate;
  154.     /**
  155.      * @internal
  156.      *
  157.      * @var int|null
  158.      */
  159.     protected ?int $o_userOwner = null;
  161.     /**
  162.      * @internal
  163.      *
  164.      * @var int|null
  165.      */
  166.     protected ?int $o_userModification = null;
  168.     /**
  169.      * @internal
  170.      *
  171.      * @var array|null
  172.      */
  173.     protected ?array $o_properties = 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.      * @var string
  211.      */
  212.     protected $o_locked;
  214.     /**
  215.      * @internal
  216.      *
  217.      * @var string|null
  218.      */
  219.     protected $o_childrenSortBy;
  221.     /**
  222.      * @internal
  223.      *
  224.      * @var string|null
  225.      */
  226.     protected $o_childrenSortOrder;
  228.     /**
  229.      * @internal
  230.      *
  231.      * @var int
  232.      */
  233.     protected $o_versionCount = 0;
  235.     /**
  236.      * @static
  237.      *
  238.      * @return bool
  239.      */
  240.     public static function getHideUnpublished()
  241.     {
  242.         return self::$hideUnpublished;
  243.     }
  245.     /**
  246.      * @static
  247.      *
  248.      * @param bool $hideUnpublished
  249.      */
  250.     public static function setHideUnpublished($hideUnpublished)
  251.     {
  252.         self::$hideUnpublished = $hideUnpublished;
  253.     }
  255.     /**
  256.      * @static
  257.      *
  258.      * @return bool
  259.      */
  260.     public static function doHideUnpublished()
  261.     {
  262.         return self::$hideUnpublished;
  263.     }
  265.     /**
  266.      * @static
  267.      *
  268.      * @param bool $getInheritedValues
  269.      */
  270.     public static function setGetInheritedValues($getInheritedValues)
  271.     {
  272.         self::$getInheritedValues = $getInheritedValues;
  273.     }
  275.     /**
  276.      * @static
  277.      *
  278.      * @return bool
  279.      */
  280.     public static function getGetInheritedValues()
  281.     {
  282.         return self::$getInheritedValues;
  283.     }
  285.     /**
  286.      * @static
  287.      *
  288.      * @param Concrete|null $object
  289.      *
  290.      * @return bool
  291.      */
  292.     public static function doGetInheritedValues(Concrete $object = null)
  293.     {
  294.         if (self::$getInheritedValues && $object !== null) {
  295.             $class = $object->getClass();
  297.             return $class->getAllowInherit();
  298.         }
  300.         return self::$getInheritedValues;
  301.     }
  303.     /**
  304.      * get possible types
  305.      *
  306.      * @return array
  307.      */
  308.     public static function getTypes()
  309.     {
  310.         return self::$types;
  311.     }
  313.     /**
  314.      * Static helper to get an object by the passed ID
  315.      *
  316.      * @param int $id
  317.      * @param bool $force
  318.      *
  319.      * @return static|null
  320.      */
  321.     public static function getById($id, $force = false)
  322.     {
  323.         if (!is_numeric($id) || $id < 1) {
  324.             return null;
  325.         }
  327.         $id = (int)$id;
  328.         $cacheKey = self::getCacheKey($id);
  330.         if (!$force && Runtime::isRegistered($cacheKey)) {
  331.             $object = Runtime::get($cacheKey);
  332.             if ($object && static::typeMatch($object)) {
  333.                 return $object;
  334.             }
  335.         }
  337.         if ($force || !($object = Cache::load($cacheKey))) {
  338.             $object = new Model\DataObject();
  340.             try {
  341.                 $typeInfo = $object->getDao()->getTypeById($id);
  343.                 if (!empty($typeInfo['o_type']) && in_array($typeInfo['o_type'], DataObject::$types)) {
  344.                     if ($typeInfo['o_type'] == DataObject::OBJECT_TYPE_FOLDER) {
  345.                         $className = Folder::class;
  346.                     } else {
  347.                         $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($typeInfo['o_className']);
  348.                     }
  350.                     /** @var AbstractObject $object */
  351.                     $object = self::getModelFactory()->build($className);
  352.                     Runtime::set($cacheKey, $object);
  353.                     $object->getDao()->getById($id);
  354.                     $object->__setDataVersionTimestamp($object->getModificationDate());
  356.                     Service::recursiveResetDirtyMap($object);
  358.                     // force loading of relation data
  359.                     if ($object instanceof Concrete) {
  360.                         $object->__getRawRelationData();
  361.                     }
  363.                     Cache::save($object, $cacheKey);
  364.                 } else {
  365.                     throw new Model\Exception\NotFoundException('No entry for object id ' . $id);
  366.                 }
  367.             } catch (Model\Exception\NotFoundException $e) {
  368.                 return null;
  369.             }
  370.         } else {
  371.             Runtime::set($cacheKey, $object);
  372.         }
  374.         if (!$object || !static::typeMatch($object)) {
  375.             return null;
  376.         }
  378.         return $object;
  379.     }
  381.     /**
  382.      * @param string $path
  383.      * @param bool $force
  384.      *
  385.      * @return static|null
  386.      */
  387.     public static function getByPath($path, $force = false)
  388.     {
  389.         if (!$path) {
  390.             return null;
  391.         }
  393.         $path = Model\Element\Service::correctPath($path);
  395.         try {
  396.             $object = new static();
  397.             $object->getDao()->getByPath($path);
  399.             return static::getById($object->getId(), $force);
  400.         } catch (Model\Exception\NotFoundException $e) {
  401.             return null;
  402.         }
  403.     }
  405.     /**
  406.      * @param array $config
  407.      *
  408.      * @return DataObject\Listing
  409.      *
  410.      * @throws \Exception
  411.      */
  412.     public static function getList($config = [])
  413.     {
  414.         $className = DataObject::class;
  415.         // get classname
  416.         if (!in_array(static::class, [__CLASS__, Concrete::class, Folder::class], true)) {
  417.             /** @var Concrete $tmpObject */
  418.             $tmpObject = new static();
  419.             if ($tmpObject instanceof Concrete) {
  420.                 $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($tmpObject->getClassName());
  421.             }
  422.         }
  424.         if (is_array($config)) {
  425.             if (!empty($config['class'])) {
  426.                 $className = ltrim($config['class'], '\\');
  427.             }
  429.             if ($className) {
  430.                 $listClass = $className . '\\Listing';
  431.                 /** @var DataObject\Listing $list */
  432.                 $list = self::getModelFactory()->build($listClass);
  433.                 $list->setValues($config);
  435.                 return $list;
  436.             }
  437.         }
  439.         throw new \Exception('Unable to initiate list class - class not found or invalid configuration');
  440.     }
  442.     /**
  443.      * @deprecated will be removed in Pimcore 11
  444.      *
  445.      * @param array $config
  446.      *
  447.      * @return int total count
  448.      */
  449.     public static function getTotalCount($config = [])
  450.     {
  451.         $list = static::getList($config);
  452.         $count = $list->getTotalCount();
  454.         return $count;
  455.     }
  457.     /**
  458.      * @internal
  459.      *
  460.      * @param AbstractObject $object
  461.      *
  462.      * @return bool
  463.      */
  464.     protected static function typeMatch(AbstractObject $object)
  465.     {
  466.         return in_array(static::class, [Concrete::class, __CLASS__], true) || $object instanceof static;
  467.     }
  469.     /**
  470.      * @param array $objectTypes
  471.      * @param bool $includingUnpublished
  472.      *
  473.      * @return DataObject[]
  474.      */
  475.     public function getChildren(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  476.     {
  477.         $cacheKey = $this->getListingCacheKey(func_get_args());
  479.         if (!isset($this->o_children[$cacheKey])) {
  480.             if ($this->getId()) {
  481.                 $list = new Listing();
  482.                 $list->setUnpublished($includingUnpublished);
  483.                 $list->setCondition('o_parentId = ?', $this->getId());
  484.                 $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  485.                 $list->setOrder($this->getChildrenSortOrder());
  486.                 $list->setObjectTypes($objectTypes);
  487.                 $this->o_children[$cacheKey] = $list->load();
  488.                 $this->o_hasChildren[$cacheKey] = (bool) count($this->o_children[$cacheKey]);
  489.             } else {
  490.                 $this->o_children[$cacheKey] = [];
  491.                 $this->o_hasChildren[$cacheKey] = false;
  492.             }
  493.         }
  495.         return $this->o_children[$cacheKey];
  496.     }
  498.     /**
  499.      * Quick test if there are children
  500.      *
  501.      * @param array $objectTypes
  502.      * @param bool|null $includingUnpublished
  503.      *
  504.      * @return bool
  505.      */
  506.     public function hasChildren($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  507.     {
  508.         $cacheKey = $this->getListingCacheKey(func_get_args());
  510.         if (isset($this->o_hasChildren[$cacheKey])) {
  511.             return $this->o_hasChildren[$cacheKey];
  512.         }
  514.         return $this->o_hasChildren[$cacheKey] = $this->getDao()->hasChildren($objectTypes, $includingUnpublished);
  515.     }
  517.     /**
  518.      * Get a list of the sibling documents
  519.      *
  520.      * @param array $objectTypes
  521.      * @param bool $includingUnpublished
  522.      *
  523.      * @return array
  524.      */
  525.     public function getSiblings(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  526.     {
  527.         $cacheKey = $this->getListingCacheKey(func_get_args());
  529.         if (!isset($this->o_siblings[$cacheKey])) {
  530.             if ($this->getParentId()) {
  531.                 $list = new Listing();
  532.                 $list->setUnpublished($includingUnpublished);
  533.                 $list->addConditionParam('o_parentId = ?', $this->getParentId());
  534.                 if ($this->getId()) {
  535.                     $list->addConditionParam('o_id != ?', $this->getId());
  536.                 }
  537.                 $list->setOrderKey('o_key');
  538.                 $list->setObjectTypes($objectTypes);
  539.                 $list->setOrder('asc');
  540.                 $this->o_siblings[$cacheKey] = $list->load();
  541.                 $this->o_hasSiblings[$cacheKey] = (bool) count($this->o_siblings[$cacheKey]);
  542.             } else {
  543.                 $this->o_siblings[$cacheKey] = [];
  544.                 $this->o_hasSiblings[$cacheKey] = false;
  545.             }
  546.         }
  548.         return $this->o_siblings[$cacheKey];
  549.     }
  551.     /**
  552.      * Returns true if the object has at least one sibling
  553.      *
  554.      * @param array $objectTypes
  555.      * @param bool|null $includingUnpublished
  556.      *
  557.      * @return bool
  558.      */
  559.     public function hasSiblings($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  560.     {
  561.         $cacheKey = $this->getListingCacheKey(func_get_args());
  563.         if (isset($this->o_hasSiblings[$cacheKey])) {
  564.             return $this->o_hasSiblings[$cacheKey];
  565.         }
  567.         return $this->o_hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($objectTypes, $includingUnpublished);
  568.     }
  570.     /**
  571.      * enum('self','propagate') nullable
  572.      *
  573.      * @return string|null
  574.      */
  575.     public function getLocked()
  576.     {
  577.         return $this->o_locked;
  578.     }
  580.     /**
  581.      * enum('self','propagate') nullable
  582.      *
  583.      * @param string|null $o_locked
  584.      *
  585.      * @return $this
  586.      */
  587.     public function setLocked($o_locked)
  588.     {
  589.         $this->o_locked = $o_locked;
  591.         return $this;
  592.     }
  594.     /**
  595.      * @internal
  596.      *
  597.      * @throws \Exception
  598.      */
  599.     protected function doDelete()
  600.     {
  601.         // delete children
  602.         $children = $this->getChildren(self::$types, true);
  603.         if (count($children) > 0) {
  604.             foreach ($children as $child) {
  605.                 $child->delete();
  606.             }
  607.         }
  609.         // remove dependencies
  610.         $d = new Model\Dependency;
  611.         $d->cleanAllForElement($this);
  613.         // remove all properties
  614.         $this->getDao()->deleteAllProperties();
  615.     }
  617.     /**
  618.      * @throws \Exception
  619.      */
  620.     public function delete()
  621.     {
  622.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::PRE_DELETE);
  624.         $this->beginTransaction();
  626.         try {
  627.             $this->doDelete();
  628.             $this->getDao()->delete();
  630.             $this->commit();
  632.             //clear parent data from registry
  633.             $parentCacheKey = self::getCacheKey($this->getParentId());
  634.             if (Runtime::isRegistered($parentCacheKey)) {
  635.                 /** @var AbstractObject $parent * */
  636.                 $parent = Runtime::get($parentCacheKey);
  637.                 if ($parent instanceof self) {
  638.                     $parent->setChildren(null);
  639.                 }
  640.             }
  641.         } catch (\Exception $e) {
  642.             try {
  643.                 $this->rollBack();
  644.             } catch (\Exception $er) {
  645.                 // PDO adapter throws exceptions if rollback fails
  646.                 Logger::info((string) $er);
  647.             }
  649.             $failureEvent = new DataObjectEvent($this);
  650.             $failureEvent->setArgument('exception', $e);
  651.             $this->dispatchEvent($failureEvent, DataObjectEvents::POST_DELETE_FAILURE);
  653.             Logger::crit((string) $e);
  655.             throw $e;
  656.         }
  658.         // empty object cache
  659.         $this->clearDependentCache();
  661.         //clear object from registry
  662.         Runtime::set(self::getCacheKey($this->getId()), null);
  664.         $this->dispatchEvent(new DataObjectEvent($this), DataObjectEvents::POST_DELETE);
  665.     }
  667.     /**
  668.      * @return $this
  669.      *
  670.      * @throws \Exception
  671.      */
  672.     public function save()
  673.     {
  674.         // additional parameters (e.g. "versionNote" for the version note)
  675.         $params = [];
  676.         if (func_num_args() && is_array(func_get_arg(0))) {
  677.             $params = func_get_arg(0);
  678.         }
  680.         $isUpdate = false;
  681.         $differentOldPath = null;
  683.         try {
  684.             $isDirtyDetectionDisabled = self::isDirtyDetectionDisabled();
  685.             $preEvent = new DataObjectEvent($this, $params);
  686.             if ($this->getId()) {
  687.                 $isUpdate = true;
  688.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_UPDATE);
  689.             } else {
  690.                 self::disableDirtyDetection();
  691.                 $this->dispatchEvent($preEvent, DataObjectEvents::PRE_ADD);
  692.             }
  694.             $params = $preEvent->getArguments();
  696.             $this->correctPath();
  698.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  699.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  700.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  701.             $maxRetries = 5;
  702.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  704.                 // be sure that unpublished objects in relations are saved also in frontend mode, eg. in importers, ...
  705.                 $hideUnpublishedBackup = self::getHideUnpublished();
  706.                 self::setHideUnpublished(false);
  708.                 $this->beginTransaction();
  710.                 try {
  711.                     if (!in_array($this->getType(), self::$types)) {
  712.                         throw new \Exception('invalid object type given: [' . $this->getType() . ']');
  713.                     }
  715.                     if (!$isUpdate) {
  716.                         $this->getDao()->create();
  717.                     }
  719.                     // get the old path from the database before the update is done
  720.                     $oldPath = null;
  721.                     if ($isUpdate) {
  722.                         $oldPath = $this->getDao()->getCurrentFullPath();
  723.                     }
  725.                     // if the old path is different from the new path, update all children
  726.                     // we need to do the update of the children's path before $this->update() because the
  727.                     // inheritance helper needs the correct paths of the children in InheritanceHelper::buildTree()
  728.                     $updatedChildren = [];
  729.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  730.                         $differentOldPath = $oldPath;
  731.                         $this->getDao()->updateWorkspaces();
  732.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  733.                     }
  735.                     $this->update($isUpdate, $params);
  737.                     self::setHideUnpublished($hideUnpublishedBackup);
  739.                     $this->commit();
  741.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  742.                 } catch (\Exception $e) {
  743.                     try {
  744.                         $this->rollBack();
  745.                     } catch (\Exception $er) {
  746.                         // PDO adapter throws exceptions if rollback fails
  747.                         Logger::info((string) $er);
  748.                     }
  750.                     // set "HideUnpublished" back to the value it was originally
  751.                     self::setHideUnpublished($hideUnpublishedBackup);
  753.                     if ($e instanceof UniqueConstraintViolationException) {
  754.                         throw new Element\ValidationException('unique constraint violation', 0, $e);
  755.                     }
  757.                     if ($e instanceof RetryableException) {
  758.                         // we try to start the transaction $maxRetries times again (deadlocks, ...)
  759.                         if ($retries < ($maxRetries - 1)) {
  760.                             $run = $retries + 1;
  761.                             $waitTime = random_int(1, 5) * 100000; // microseconds
  762.                             Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  764.                             usleep($waitTime); // wait specified time until we restart the transaction
  765.                         } else {
  766.                             // if the transaction still fail after $maxRetries retries, we throw out the exception
  767.                             Logger::error('Finally giving up restarting the same transaction again and again, last message: ' . $e->getMessage());
  769.                             throw $e;
  770.                         }
  771.                     } else {
  772.                         throw $e;
  773.                     }
  774.                 }
  775.             }
  777.             $additionalTags = [];
  778.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  779.                 foreach ($updatedChildren as $objectId) {
  780.                     $tag = 'object_' . $objectId;
  781.                     $additionalTags[] = $tag;
  783.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  784.                     Runtime::set($tag, null);
  785.                 }
  786.             }
  787.             $this->clearDependentCache($additionalTags);
  789.             $postEvent = new DataObjectEvent($this, $params);
  790.             if ($isUpdate) {
  791.                 if ($differentOldPath) {
  792.                     $postEvent->setArgument('oldPath', $differentOldPath);
  793.                 }
  794.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_UPDATE);
  795.             } else {
  796.                 self::setDisableDirtyDetection($isDirtyDetectionDisabled);
  797.                 $this->dispatchEvent($postEvent, DataObjectEvents::POST_ADD);
  798.             }
  800.             return $this;
  801.         } catch (\Exception $e) {
  802.             $failureEvent = new DataObjectEvent($this, $params);
  803.             $failureEvent->setArgument('exception', $e);
  804.             if ($isUpdate) {
  805.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_UPDATE_FAILURE);
  806.             } else {
  807.                 $this->dispatchEvent($failureEvent, DataObjectEvents::POST_ADD_FAILURE);
  808.             }
  810.             throw $e;
  811.         }
  812.     }
  814.     /**
  815.      * @internal
  816.      *
  817.      * @throws \Exception|DuplicateFullPathException
  818.      */
  819.     protected function correctPath()
  820.     {
  821.         // set path
  822.         if ($this->getId() != 1) { // not for the root node
  824.             if (!Element\Service::isValidKey($this->getKey(), 'object')) {
  825.                 throw new \Exception('invalid key for object with id [ '.$this->getId().' ] key is: [' . $this->getKey() . ']');
  826.             }
  828.             if ($this->getParentId() == $this->getId()) {
  829.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  830.             }
  832.             $parent = DataObject::getById($this->getParentId());
  834.             if ($parent) {
  835.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  836.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  837.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath().'/'));
  838.             } else {
  839.                 // parent document doesn't exist anymore, set the parent to to root
  840.                 $this->setParentId(1);
  841.                 $this->setPath('/');
  842.             }
  844.             if (strlen($this->getKey()) < 1) {
  845.                 throw new \Exception('DataObject requires key');
  846.             }
  847.         } elseif ($this->getId() == 1) {
  848.             // some data in root node should always be the same
  849.             $this->setParentId(0);
  850.             $this->setPath('/');
  851.             $this->setKey('');
  852.             $this->setType(DataObject::OBJECT_TYPE_FOLDER);
  853.         }
  855.         if (Service::pathExists($this->getRealFullPath())) {
  856.             $duplicate = DataObject::getByPath($this->getRealFullPath());
  857.             if ($duplicate instanceof self && $duplicate->getId() != $this->getId()) {
  858.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ '.$this->getRealFullPath().' ] - cannot save object');
  859.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  861.                 throw $duplicateFullPathException;
  862.             }
  863.         }
  865.         $this->validatePathLength();
  866.     }
  868.     /**
  869.      * @internal
  870.      *
  871.      * @param bool|null $isUpdate
  872.      * @param array $params
  873.      *
  874.      * @throws \Exception
  875.      */
  876.     protected function update($isUpdate = null, $params = [])
  877.     {
  878.         $this->updateModificationInfos();
  880.         // save properties
  881.         $this->getProperties();
  882.         $this->getDao()->deleteAllProperties();
  884.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  885.             foreach ($this->getProperties() as $property) {
  886.                 if (!$property->getInherited()) {
  887.                     $property->setDao(null);
  888.                     $property->setCid($this->getId());
  889.                     $property->setCtype('object');
  890.                     $property->setCpath($this->getRealFullPath());
  891.                     $property->save();
  892.                 }
  893.             }
  894.         }
  896.         // save dependencies
  897.         $d = new Model\Dependency();
  898.         $d->setSourceType('object');
  899.         $d->setSourceId($this->getId());
  901.         foreach ($this->resolveDependencies() as $requirement) {
  902.             if ($requirement['id'] == $this->getId() && $requirement['type'] === 'object') {
  903.                 // dont't add a reference to yourself
  904.                 continue;
  905.             }
  907.             $d->addRequirement($requirement['id'], $requirement['type']);
  908.         }
  910.         $d->save();
  912.         //set object to registry
  913.         Runtime::set(self::getCacheKey($this->getId()), $this);
  914.     }
  916.     /**
  917.      * {@inheritdoc}
  918.      */
  919.     public function clearDependentCache($additionalTags = [])
  920.     {
  921.         self::clearDependentCacheByObjectId($this->getId(), $additionalTags);
  922.     }
  924.     /**
  925.      * @internal
  926.      *
  927.      * @param int $objectId
  928.      * @param array $additionalTags
  929.      */
  930.     public static function clearDependentCacheByObjectId($objectId, $additionalTags = [])
  931.     {
  932.         if (!$objectId) {
  933.             throw new \Exception('object ID missing');
  934.         }
  936.         try {
  937.             $tags = ['object_' . $objectId, 'object_properties', 'output'];
  938.             $tags = array_merge($tags, $additionalTags);
  940.             Cache::clearTags($tags);
  941.         } catch (\Exception $e) {
  942.             Logger::crit((string) $e);
  943.         }
  944.     }
  946.     /**
  947.      * @internal
  948.      *
  949.      * @param int $index
  950.      */
  951.     public function saveIndex($index)
  952.     {
  953.         $this->getDao()->saveIndex($index);
  954.         $this->clearDependentCache();
  955.     }
  957.     /**
  958.      * @return string
  959.      */
  960.     public function getFullPath()
  961.     {
  962.         $path = $this->getPath() . $this->getKey();
  964.         return $path;
  965.     }
  967.     /**
  968.      * @return string
  969.      */
  970.     public function getRealPath()
  971.     {
  972.         return $this->getPath();
  973.     }
  975.     /**
  976.      * @return string
  977.      */
  978.     public function getRealFullPath()
  979.     {
  980.         return $this->getFullPath();
  981.     }
  983.     /**
  984.      * @return int|null
  985.      */
  986.     public function getId()
  987.     {
  988.         return $this->o_id;
  989.     }
  991.     /**
  992.      * @return int|null
  993.      */
  994.     public function getParentId()
  995.     {
  996.         // fall back to parent if no ID is set but we have a parent object
  997.         if (!$this->o_parentId && $this->o_parent) {
  998.             return $this->o_parent->getId();
  999.         }
  1001.         return $this->o_parentId;
  1002.     }
  1004.     /**
  1005.      * @return string
  1006.      */
  1007.     public function getType()
  1008.     {
  1009.         return $this->o_type;
  1010.     }
  1012.     /**
  1013.      * @return string|null
  1014.      */
  1015.     public function getKey()
  1016.     {
  1017.         return $this->o_key;
  1018.     }
  1020.     /**
  1021.      * @return string|null
  1022.      */
  1023.     public function getPath()
  1024.     {
  1025.         return $this->o_path;
  1026.     }
  1028.     /**
  1029.      * @return int
  1030.      */
  1031.     public function getIndex()
  1032.     {
  1033.         return $this->o_index;
  1034.     }
  1036.     /**
  1037.      * @return int|null
  1038.      */
  1039.     public function getCreationDate()
  1040.     {
  1041.         return $this->o_creationDate;
  1042.     }
  1044.     /**
  1045.      * @return int|null
  1046.      */
  1047.     public function getModificationDate()
  1048.     {
  1049.         return $this->o_modificationDate;
  1050.     }
  1052.     /**
  1053.      * @return int|null
  1054.      */
  1055.     public function getUserOwner()
  1056.     {
  1057.         return $this->o_userOwner;
  1058.     }
  1060.     /**
  1061.      * @return int
  1062.      */
  1063.     public function getUserModification()
  1064.     {
  1065.         return $this->o_userModification;
  1066.     }
  1068.     /**
  1069.      * @param int|null $o_id
  1070.      *
  1071.      * @return $this
  1072.      */
  1073.     public function setId($o_id)
  1074.     {
  1075.         $this->o_id = $o_id ? (int)$o_id : null;
  1077.         return $this;
  1078.     }
  1080.     /**
  1081.      * @param int $o_parentId
  1082.      *
  1083.      * @return $this
  1084.      */
  1085.     public function setParentId($o_parentId)
  1086.     {
  1087.         $o_parentId = (int) $o_parentId;
  1088.         if ($o_parentId != $this->o_parentId) {
  1089.             $this->markFieldDirty('o_parentId');
  1090.         }
  1091.         $this->o_parentId = $o_parentId;
  1092.         $this->o_parent = null;
  1093.         $this->o_siblings = [];
  1094.         $this->o_hasSiblings = [];
  1096.         return $this;
  1097.     }
  1099.     /**
  1100.      * @param string $o_type
  1101.      *
  1102.      * @return $this
  1103.      */
  1104.     public function setType($o_type)
  1105.     {
  1106.         $this->o_type = $o_type;
  1108.         return $this;
  1109.     }
  1111.     /**
  1112.      * @param string $o_key
  1113.      *
  1114.      * @return $this
  1115.      */
  1116.     public function setKey($o_key)
  1117.     {
  1118.         $this->o_key = (string)$o_key;
  1120.         return $this;
  1121.     }
  1123.     /**
  1124.      * @param string $o_path
  1125.      *
  1126.      * @return $this
  1127.      */
  1128.     public function setPath($o_path)
  1129.     {
  1130.         $this->o_path = $o_path;
  1132.         return $this;
  1133.     }
  1135.     /**
  1136.      * @param int $o_index
  1137.      *
  1138.      * @return $this
  1139.      */
  1140.     public function setIndex($o_index)
  1141.     {
  1142.         $this->o_index = (int) $o_index;
  1144.         return $this;
  1145.     }
  1147.     /**
  1148.      * @param string|null $childrenSortBy
  1149.      */
  1150.     public function setChildrenSortBy($childrenSortBy)
  1151.     {
  1152.         if ($this->o_childrenSortBy !== $childrenSortBy) {
  1153.             $this->o_children = [];
  1154.             $this->o_hasChildren = [];
  1155.         }
  1156.         $this->o_childrenSortBy = $childrenSortBy;
  1157.     }
  1159.     /**
  1160.      * @param int $o_creationDate
  1161.      *
  1162.      * @return $this
  1163.      */
  1164.     public function setCreationDate($o_creationDate)
  1165.     {
  1166.         $this->o_creationDate = (int) $o_creationDate;
  1168.         return $this;
  1169.     }
  1171.     /**
  1172.      * @param int $o_modificationDate
  1173.      *
  1174.      * @return $this
  1175.      */
  1176.     public function setModificationDate($o_modificationDate)
  1177.     {
  1178.         $this->markFieldDirty('o_modificationDate');
  1180.         $this->o_modificationDate = (int) $o_modificationDate;
  1182.         return $this;
  1183.     }
  1185.     /**
  1186.      * @param int $o_userOwner
  1187.      *
  1188.      * @return $this
  1189.      */
  1190.     public function setUserOwner($o_userOwner)
  1191.     {
  1192.         $this->o_userOwner = (int) $o_userOwner;
  1194.         return $this;
  1195.     }
  1197.     /**
  1198.      * @param int $o_userModification
  1199.      *
  1200.      * @return $this
  1201.      */
  1202.     public function setUserModification($o_userModification)
  1203.     {
  1204.         $this->markFieldDirty('o_userModification');
  1206.         $this->o_userModification = (int) $o_userModification;
  1208.         return $this;
  1209.     }
  1211.     /**
  1212.      * @param DataObject[]|null $children
  1213.      * @param array $objectTypes
  1214.      * @param bool $includingUnpublished
  1215.      *
  1216.      * @return $this
  1217.      */
  1218.     public function setChildren($children, array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  1219.     {
  1220.         if ($children === null) {
  1221.             // unset all cached children
  1222.             $this->o_children = [];
  1223.             $this->o_hasChildren = [];
  1224.         } elseif (is_array($children)) {
  1225.             //default cache key
  1226.             $cacheKey = $this->getListingCacheKey([$objectTypes, $includingUnpublished]);
  1227.             $this->o_children[$cacheKey] = $children;
  1228.             $this->o_hasChildren[$cacheKey] = (bool) count($children);
  1229.         }
  1231.         return $this;
  1232.     }
  1234.     /**
  1235.      * @return self|null
  1236.      */
  1237.     public function getParent()
  1238.     {
  1239.         if ($this->o_parent === null) {
  1240.             $this->setParent(DataObject::getById($this->getParentId()));
  1241.         }
  1243.         return $this->o_parent;
  1244.     }
  1246.     /**
  1247.      * @param self|null $o_parent
  1248.      *
  1249.      * @return $this
  1250.      */
  1251.     public function setParent($o_parent)
  1252.     {
  1253.         $newParentId = $o_parent instanceof self ? $o_parent->getId() : 0;
  1254.         $this->setParentId($newParentId);
  1255.         $this->o_parent = $o_parent;
  1257.         return $this;
  1258.     }
  1260.     /**
  1261.      * @return Model\Property[]
  1262.      */
  1263.     public function getProperties()
  1264.     {
  1265.         if ($this->o_properties === null) {
  1266.             // try to get from cache
  1267.             $cacheKey = 'object_properties_' . $this->getId();
  1268.             $properties = Cache::load($cacheKey);
  1269.             if (!is_array($properties)) {
  1270.                 $properties = $this->getDao()->getProperties();
  1271.                 $elementCacheTag = $this->getCacheTag();
  1272.                 $cacheTags = ['object_properties' => 'object_properties', $elementCacheTag => $elementCacheTag];
  1273.                 Cache::save($properties, $cacheKey, $cacheTags);
  1274.             }
  1276.             $this->setProperties($properties);
  1277.         }
  1279.         return $this->o_properties;
  1280.     }
  1282.     /**
  1283.      * {@inheritdoc}
  1284.      */
  1285.     public function setProperties(?array $properties)
  1286.     {
  1287.         $this->o_properties = $properties;
  1289.         return $this;
  1290.     }
  1292.     /**
  1293.      * @param string $name
  1294.      * @param string $type
  1295.      * @param mixed $data
  1296.      * @param bool $inherited
  1297.      * @param bool $inheritable
  1298.      *
  1299.      * @return $this
  1300.      */
  1301.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1302.     {
  1303.         $this->getProperties();
  1305.         $property = new Model\Property();
  1306.         $property->setType($type);
  1307.         $property->setCid($this->getId());
  1308.         $property->setName($name);
  1309.         $property->setCtype('object');
  1310.         $property->setData($data);
  1311.         $property->setInherited($inherited);
  1312.         $property->setInheritable($inheritable);
  1314.         $this->o_properties[$name] = $property;
  1316.         return $this;
  1317.     }
  1319.     /**
  1320.      * @return string
  1321.      */
  1322.     public function getChildrenSortBy()
  1323.     {
  1324.         return $this->o_childrenSortBy ?? self::OBJECT_CHILDREN_SORT_BY_DEFAULT;
  1325.     }
  1327.     public function __sleep()
  1328.     {
  1329.         $parentVars = parent::__sleep();
  1331.         $blockedVars = ['o_hasChildren', 'o_versions', 'o_class', 'scheduledTasks', 'o_parent', 'omitMandatoryCheck'];
  1333.         if ($this->isInDumpState()) {
  1334.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  1335.             $blockedVars = array_merge($blockedVars, ['o_dirtyFields']);
  1336.             $this->removeInheritedProperties();
  1337.         } else {
  1338.             // this is if we want to cache the object
  1339.             $blockedVars = array_merge($blockedVars, ['o_children', 'o_properties']);
  1340.         }
  1342.         return array_diff($parentVars, $blockedVars);
  1343.     }
  1345.     public function __wakeup()
  1346.     {
  1347.         if ($this->isInDumpState() && !self::$doNotRestoreKeyAndPath) {
  1348.             // set current key and path this is necessary because the serialized data can have a different path than the original element ( element was renamed or moved )
  1349.             $originalElement = DataObject::getById($this->getId());
  1350.             if ($originalElement) {
  1351.                 $this->setKey($originalElement->getKey());
  1352.                 $this->setPath($originalElement->getRealPath());
  1353.             }
  1354.         }
  1356.         if ($this->isInDumpState() && $this->o_properties !== null) {
  1357.             $this->renewInheritedProperties();
  1358.         }
  1360.         $this->setInDumpState(false);
  1361.     }
  1363.     /**
  1364.      * @param string $method
  1365.      * @param array $args
  1366.      *
  1367.      * @return mixed
  1368.      *
  1369.      * @throws \Exception
  1370.      */
  1371.     public function __call($method, $args)
  1372.     {
  1374.         // compatibility mode (they do not have any set_oXyz() methods anymore)
  1375.         if (preg_match('/^(get|set)o_/i', $method)) {
  1376.             $newMethod = preg_replace('/^(get|set)o_/i', '$1', $method);
  1377.             if (method_exists($this, $newMethod)) {
  1378.                 $r = call_user_func_array([$this, $newMethod], $args);
  1380.                 return $r;
  1381.             }
  1382.         }
  1384.         return parent::__call($method, $args);
  1385.     }
  1387.     /**
  1388.      * @return bool
  1389.      */
  1390.     public static function doNotRestoreKeyAndPath()
  1391.     {
  1392.         return self::$doNotRestoreKeyAndPath;
  1393.     }
  1395.     /**
  1396.      * @param bool $doNotRestoreKeyAndPath
  1397.      */
  1398.     public static function setDoNotRestoreKeyAndPath($doNotRestoreKeyAndPath)
  1399.     {
  1400.         self::$doNotRestoreKeyAndPath = $doNotRestoreKeyAndPath;
  1401.     }
  1403.     /**
  1404.      * @param string $fieldName
  1405.      * @param string|null $language
  1406.      *
  1407.      * @throws \Exception
  1408.      *
  1409.      * @return mixed
  1410.      */
  1411.     public function get($fieldName, $language = null)
  1412.     {
  1413.         if (!$fieldName) {
  1414.             throw new \Exception('Field name must not be empty.');
  1415.         }
  1417.         return $this->{'get'.ucfirst($fieldName)}($language);
  1418.     }
  1420.     /**
  1421.      * @param string $fieldName
  1422.      * @param mixed $value
  1423.      * @param string|null $language
  1424.      *
  1425.      * @throws \Exception
  1426.      *
  1427.      * @return mixed
  1428.      */
  1429.     public function set($fieldName, $value, $language = null)
  1430.     {
  1431.         if (!$fieldName) {
  1432.             throw new \Exception('Field name must not be empty.');
  1433.         }
  1435.         return $this->{'set'.ucfirst($fieldName)}($value, $language);
  1436.     }
  1438.     /**
  1439.      * @internal
  1440.      *
  1441.      * @return bool
  1442.      */
  1443.     public static function isDirtyDetectionDisabled()
  1444.     {
  1445.         return self::$disableDirtyDetection;
  1446.     }
  1448.     /**
  1449.      * @internal
  1450.      *
  1451.      * @param bool $disableDirtyDetection
  1452.      */
  1453.     public static function setDisableDirtyDetection(bool $disableDirtyDetection)
  1454.     {
  1455.         self::$disableDirtyDetection = $disableDirtyDetection;
  1456.     }
  1458.     /**
  1459.      * @internal
  1460.      */
  1461.     public static function disableDirtyDetection()
  1462.     {
  1463.         self::setDisableDirtyDetection(true);
  1464.     }
  1466.     /**
  1467.      * @internal
  1468.      */
  1469.     public static function enableDirtyDetection()
  1470.     {
  1471.         self::setDisableDirtyDetection(false);
  1472.     }
  1474.     /**
  1475.      * @return int
  1476.      */
  1477.     public function getVersionCount(): int
  1478.     {
  1479.         return $this->o_versionCount ? $this->o_versionCount : 0;
  1480.     }
  1482.     /**
  1483.      * @param int|null $o_versionCount
  1484.      *
  1485.      * @return AbstractObject
  1486.      */
  1487.     public function setVersionCount(?int $o_versionCount): Element\ElementInterface
  1488.     {
  1489.         $this->o_versionCount = (int) $o_versionCount;
  1491.         return $this;
  1492.     }
  1494.     /**
  1495.      * @internal
  1496.      *
  1497.      * @param array $args
  1498.      *
  1499.      * @return string
  1500.      */
  1501.     protected function getListingCacheKey(array $args = [])
  1502.     {
  1503.         $objectTypes = $args[0] ?? [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER];
  1504.         $includingUnpublished = (bool)($args[1] ?? false);
  1506.         if (is_array($objectTypes)) {
  1507.             $objectTypes = implode('_', $objectTypes);
  1508.         }
  1510.         $cacheKey = $objectTypes . (!empty($includingUnpublished) ? '_' : '') . (string)$includingUnpublished;
  1512.         return $cacheKey;
  1513.     }
  1515.     /**
  1516.      * @param string | null $o_reverseSort
  1517.      *
  1518.      * @return AbstractObject
  1519.      */
  1520.     public function setChildrenSortOrder(?string $o_reverseSort): Element\ElementInterface
  1521.     {
  1522.         $this->o_childrenSortOrder = $o_reverseSort;
  1524.         return $this;
  1525.     }
  1527.     /**
  1528.      * @return string
  1529.      */
  1530.     public function getChildrenSortOrder(): string
  1531.     {
  1532.         return $this->o_childrenSortOrder ?? self::OBJECT_CHILDREN_SORT_ORDER_DEFAULT;
  1533.     }
  1535.     /**
  1536.      * load lazy loaded fields before cloning
  1537.      */
  1538.     public function __clone()
  1539.     {
  1540.         parent::__clone();
  1541.         $this->o_parent = null;
  1542.         // note that o_children is currently needed for the recycle bin
  1543.         $this->o_hasSiblings = [];
  1544.         $this->o_siblings = [];
  1545.     }
  1547.     /**
  1548.      * @param string $method
  1549.      * @param array $arguments
  1550.      *
  1551.      * @return mixed|Listing|null
  1552.      *
  1553.      * @throws \Exception
  1554.      */
  1555.     public static function __callStatic($method, $arguments)
  1556.     {
  1557.         $propertyName = lcfirst(preg_replace('/^getBy/i', '', $method));
  1559.         $realPropertyName = 'o_'.$propertyName;
  1561.         $db = \Pimcore\Db::get();
  1563.         if (in_array(strtolower($realPropertyName), self::$objectColumns)) {
  1564.             $arguments = array_pad($arguments, 4, 0);
  1565.             [$value, $limit, $offset, $objectTypes] = $arguments;
  1567.             $defaultCondition = $realPropertyName.' = '.Db::get()->quote($value).' ';
  1569.             $listConfig = [
  1570.                 'condition' => $defaultCondition,
  1571.             ];
  1573.             if (!is_array($limit)) {
  1574.                 if ($limit) {
  1575.                     $listConfig['limit'] = $limit;
  1576.                 }
  1577.                 if ($offset) {
  1578.                     $listConfig['offset'] = $offset;
  1579.                 }
  1580.             } else {
  1581.                 $listConfig = array_merge($listConfig, $limit);
  1582.                 $limitCondition = $limit['condition'] ?? '';
  1583.                 $listConfig['condition'] = $defaultCondition.$limitCondition;
  1584.             }
  1586.             $list = static::makeList($listConfig, $objectTypes);
  1588.             if (isset($listConfig['limit']) && $listConfig['limit'] == 1) {
  1589.                 $elements = $list->getObjects();
  1591.                 return isset($elements[0]) ? $elements[0] : null;
  1592.             }
  1594.             return $list;
  1595.         }
  1597.         // there is no property for the called method, so throw an exception
  1598.         Logger::error('Class: DataObject\\AbstractObject => call to undefined static method ' . $method);
  1600.         throw new \Exception('Call to undefined static method ' . $method . ' in class DataObject\\AbstractObject');
  1601.     }
  1603.     /**
  1604.      * @param  array  $listConfig
  1605.      * @param  mixed $objectTypes
  1606.      *
  1607.      * @return Listing
  1608.      *
  1609.      * @throws \Exception
  1610.      */
  1611.     protected static function makeList(array $listConfig, mixed $objectTypes): Listing
  1612.     {
  1613.         $list = static::getList($listConfig);
  1615.         // Check if variants, in addition to objects, to be fetched
  1616.         if (!empty($objectTypes)) {
  1617.             if (\array_diff($objectTypes, [static::OBJECT_TYPE_VARIANT, static::OBJECT_TYPE_OBJECT])) {
  1618.                 Logger::error('Class: DataObject\\AbstractObject => Unsupported object type in array ' . implode(',', $objectTypes));
  1620.                 throw new \Exception('Unsupported object type in array [' . implode(',', $objectTypes) . '] in class DataObject\\AbstractObject');
  1621.             }
  1623.             $list->setObjectTypes($objectTypes);
  1624.         }
  1626.         return $list;
  1627.     }
  1628. }