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

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;
  30. /**
  31.  * @method AbstractObject\Dao getDao()
  32.  * @method array|null getPermissions(string $type, Model\User $user, bool $quote = true)
  33.  * @method bool __isBasedOnLatestData()
  34.  * @method string getCurrentFullPath()
  35.  * @method int getChildAmount($objectTypes = [DataObject::OBJECT_TYPE_OBJECT, DataObject::OBJECT_TYPE_FOLDER], Model\User $user = null)
  36.  * @method array getChildPermissions(string $type, Model\User $user, bool $quote = true)
  37.  */
  38. abstract class AbstractObject extends Model\Element\AbstractElement
  39. {
  40.     const OBJECT_TYPE_FOLDER = 'folder';
  42.     const OBJECT_TYPE_OBJECT = 'object';
  44.     const OBJECT_TYPE_VARIANT = 'variant';
  46.     const OBJECT_CHILDREN_SORT_BY_DEFAULT = 'key';
  48.     const OBJECT_CHILDREN_SORT_BY_INDEX = 'index';
  50.     const OBJECT_CHILDREN_SORT_ORDER_DEFAULT = 'ASC';
  52.     /**
  53.      * @internal
  54.      *
  55.      * @var bool
  56.      */
  57.     public static $doNotRestoreKeyAndPath = false;
  59.     /**
  60.      * possible types of a document
  61.      *
  62.      * @var array
  63.      */
  64.     public static $types = [self::OBJECT_TYPE_FOLDER, self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_VARIANT];
  66.     /**
  67.      * @var bool
  68.      */
  69.     private static $hideUnpublished = false;
  71.     /**
  72.      * @var bool
  73.      */
  74.     private static $getInheritedValues = false;
  76.     /**
  77.      * @internal
  78.      *
  79.      * @var bool
  80.      */
  81.     protected static $disableDirtyDetection = false;
  83.     /**
  84.      * @internal
  85.      *
  86.      * @var string[]
  87.      */
  88.     protected static $objectColumns = ['o_id', 'o_parentid', 'o_type', 'o_key', 'o_classid', 'o_classname', 'o_path'];
  90.     /**
  91.      * @internal
  92.      *
  93.      * @var int|null
  94.      */
  95.     protected $o_id;
  97.     /**
  98.      * @internal
  99.      *
  100.      * @var int|null
  101.      */
  102.     protected $o_parentId;
  104.     /**
  105.      * @internal
  106.      *
  107.      * @var self|null
  108.      */
  109.     protected $o_parent;
  111.     /**
  112.      * @internal
  113.      *
  114.      * @var string
  115.      */
  116.     protected $o_type = 'object';
  118.     /**
  119.      * @internal
  120.      *
  121.      * @var string|null
  122.      */
  123.     protected $o_key;
  125.     /**
  126.      * @internal
  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.      * @var int|null
  143.      */
  144.     protected $o_creationDate;
  146.     /**
  147.      * @internal
  148.      *
  149.      * @var int|null
  150.      */
  151.     protected $o_modificationDate;
  153.     /**
  154.      * @internal
  155.      *
  156.      * @var int|null
  157.      */
  158.     protected ?int $o_userOwner = null;
  160.     /**
  161.      * @internal
  162.      *
  163.      * @var int|null
  164.      */
  165.     protected ?int $o_userModification = null;
  167.     /**
  168.      * @internal
  169.      *
  170.      * @var array|null
  171.      */
  172.     protected ?array $o_properties = null;
  174.     /**
  175.      * @internal
  176.      *
  177.      * @var bool[]
  178.      */
  179.     protected $o_hasChildren = [];
  181.     /**
  182.      * Contains a list of sibling documents
  183.      *
  184.      * @internal
  185.      *
  186.      * @var array
  187.      */
  188.     protected $o_siblings = [];
  190.     /**
  191.      * Indicator if object has siblings or not
  192.      *
  193.      * @internal
  194.      *
  195.      * @var bool[]
  196.      */
  197.     protected $o_hasSiblings = [];
  199.     /**
  200.      * @internal
  201.      *
  202.      * @var array
  203.      */
  204.     protected $o_children = [];
  206.     /**
  207.      * @internal
  208.      *
  209.      * @var string
  210.      */
  211.     protected $o_locked;
  213.     /**
  214.      * @internal
  215.      *
  216.      * @var string|null
  217.      */
  218.     protected $o_childrenSortBy;
  220.     /**
  221.      * @internal
  222.      *
  223.      * @var string|null
  224.      */
  225.     protected $o_childrenSortOrder;
  227.     /**
  228.      * @internal
  229.      *
  230.      * @var int
  231.      */
  232.     protected $o_versionCount = 0;
  234.     /**
  235.      * @static
  236.      *
  237.      * @return bool
  238.      */
  239.     public static function getHideUnpublished()
  240.     {
  241.         return self::$hideUnpublished;
  242.     }
  244.     /**
  245.      * @static
  246.      *
  247.      * @param bool $hideUnpublished
  248.      */
  249.     public static function setHideUnpublished($hideUnpublished)
  250.     {
  251.         self::$hideUnpublished = $hideUnpublished;
  252.     }
  254.     /**
  255.      * @static
  256.      *
  257.      * @return bool
  258.      */
  259.     public static function doHideUnpublished()
  260.     {
  261.         return self::$hideUnpublished;
  262.     }
  264.     /**
  265.      * @static
  266.      *
  267.      * @param bool $getInheritedValues
  268.      */
  269.     public static function setGetInheritedValues($getInheritedValues)
  270.     {
  271.         self::$getInheritedValues = $getInheritedValues;
  272.     }
  274.     /**
  275.      * @static
  276.      *
  277.      * @return bool
  278.      */
  279.     public static function getGetInheritedValues()
  280.     {
  281.         return self::$getInheritedValues;
  282.     }
  284.     /**
  285.      * @static
  286.      *
  287.      * @param Concrete $object
  288.      *
  289.      * @return bool
  290.      */
  291.     public static function doGetInheritedValues(Concrete $object = null)
  292.     {
  293.         if (self::$getInheritedValues && $object !== null) {
  294.             $class = $object->getClass();
  296.             return $class->getAllowInherit();
  297.         }
  299.         return self::$getInheritedValues;
  300.     }
  302.     /**
  303.      * get possible types
  304.      *
  305.      * @return array
  306.      */
  307.     public static function getTypes()
  308.     {
  309.         return self::$types;
  310.     }
  312.     /**
  313.      * Static helper to get an object by the passed ID
  314.      *
  315.      * @param int $id
  316.      * @param bool $force
  317.      *
  318.      * @return static|null
  319.      */
  320.     public static function getById($id, $force = false)
  321.     {
  322.         if (!is_numeric($id) || $id < 1) {
  323.             return null;
  324.         }
  326.         $id = (int)$id;
  327.         $cacheKey = self::getCacheKey($id);
  329.         if (!$force && Runtime::isRegistered($cacheKey)) {
  330.             $object = Runtime::get($cacheKey);
  331.             if ($object && static::typeMatch($object)) {
  332.                 return $object;
  333.             }
  334.         }
  336.         if ($force || !($object = Cache::load($cacheKey))) {
  337.             $object = new Model\DataObject();
  339.             try {
  340.                 $typeInfo = $object->getDao()->getTypeById($id);
  342.                 if (!empty($typeInfo['o_type']) && in_array($typeInfo['o_type'], DataObject::$types)) {
  343.                     if ($typeInfo['o_type'] == DataObject::OBJECT_TYPE_FOLDER) {
  344.                         $className = Folder::class;
  345.                     } else {
  346.                         $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($typeInfo['o_className']);
  347.                     }
  349.                     /** @var AbstractObject $object */
  350.                     $object = self::getModelFactory()->build($className);
  351.                     Runtime::set($cacheKey, $object);
  352.                     $object->getDao()->getById($id);
  353.                     $object->__setDataVersionTimestamp($object->getModificationDate());
  355.                     Service::recursiveResetDirtyMap($object);
  357.                     // force loading of relation data
  358.                     if ($object instanceof Concrete) {
  359.                         $object->__getRawRelationData();
  360.                     }
  362.                     Cache::save($object, $cacheKey);
  363.                 } else {
  364.                     throw new Model\Exception\NotFoundException('No entry for object id ' . $id);
  365.                 }
  366.             } catch (Model\Exception\NotFoundException $e) {
  367.                 return null;
  368.             }
  369.         } else {
  370.             Runtime::set($cacheKey, $object);
  371.         }
  373.         if (!$object || !static::typeMatch($object)) {
  374.             return null;
  375.         }
  377.         return $object;
  378.     }
  380.     /**
  381.      * @param string $path
  382.      * @param bool $force
  383.      *
  384.      * @return static|null
  385.      */
  386.     public static function getByPath($path, $force = false)
  387.     {
  388.         if (!$path) {
  389.             return null;
  390.         }
  392.         $path = Model\Element\Service::correctPath($path);
  394.         try {
  395.             $object = new static();
  396.             $object->getDao()->getByPath($path);
  398.             return static::getById($object->getId(), $force);
  399.         } catch (Model\Exception\NotFoundException $e) {
  400.             return null;
  401.         }
  402.     }
  404.     /**
  405.      * @param array $config
  406.      *
  407.      * @return DataObject\Listing
  408.      *
  409.      * @throws \Exception
  410.      */
  411.     public static function getList($config = [])
  412.     {
  413.         $className = DataObject::class;
  414.         // get classname
  415.         if (!in_array(static::class, [__CLASS__, Concrete::class, Folder::class], true)) {
  416.             /** @var Concrete $tmpObject */
  417.             $tmpObject = new static();
  418.             if ($tmpObject instanceof Concrete) {
  419.                 $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($tmpObject->getClassName());
  420.             }
  421.         }
  423.         if (is_array($config)) {
  424.             if (!empty($config['class'])) {
  425.                 $className = ltrim($config['class'], '\\');
  426.             }
  428.             if ($className) {
  429.                 $listClass = $className . '\\Listing';
  430.                 /** @var DataObject\Listing $list */
  431.                 $list = self::getModelFactory()->build($listClass);
  432.                 $list->setValues($config);
  434.                 return $list;
  435.             }
  436.         }
  438.         throw new \Exception('Unable to initiate list class - class not found or invalid configuration');
  439.     }
  441.     /**
  442.      * @deprecated will be removed in Pimcore 11
  443.      *
  444.      * @param array $config
  445.      *
  446.      * @return int total count
  447.      */
  448.     public static function getTotalCount($config = [])
  449.     {
  450.         $list = static::getList($config);
  451.         $count = $list->getTotalCount();
  453.         return $count;
  454.     }
  456.     /**
  457.      * @internal
  458.      *
  459.      * @param AbstractObject $object
  460.      *
  461.      * @return bool
  462.      */
  463.     protected static function typeMatch(AbstractObject $object)
  464.     {
  465.         return in_array(static::class, [Concrete::class, __CLASS__], true) || $object instanceof static;
  466.     }
  468.     /**
  469.      * @param array $objectTypes
  470.      * @param bool $includingUnpublished
  471.      *
  472.      * @return self[]
  473.      */
  474.     public function getChildren(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  475.     {
  476.         $cacheKey = $this->getListingCacheKey(func_get_args());
  478.         if (!isset($this->o_children[$cacheKey])) {
  479.             if ($this->getId()) {
  480.                 $list = new Listing();
  481.                 $list->setUnpublished($includingUnpublished);
  482.                 $list->setCondition('o_parentId = ?', $this->getId());
  483.                 $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  484.                 $list->setOrder($this->getChildrenSortOrder());
  485.                 $list->setObjectTypes($objectTypes);
  486.                 $this->o_children[$cacheKey] = $list->load();
  487.                 $this->o_hasChildren[$cacheKey] = (bool) count($this->o_children[$cacheKey]);
  488.             } else {
  489.                 $this->o_children[$cacheKey] = [];
  490.                 $this->o_hasChildren[$cacheKey] = false;
  491.             }
  492.         }
  494.         return $this->o_children[$cacheKey];
  495.     }
  497.     /**
  498.      * Quick test if there are children
  499.      *
  500.      * @param array $objectTypes
  501.      * @param bool|null $includingUnpublished
  502.      *
  503.      * @return bool
  504.      */
  505.     public function hasChildren($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  506.     {
  507.         $cacheKey = $this->getListingCacheKey(func_get_args());
  509.         if (isset($this->o_hasChildren[$cacheKey])) {
  510.             return $this->o_hasChildren[$cacheKey];
  511.         }
  513.         return $this->o_hasChildren[$cacheKey] = $this->getDao()->hasChildren($objectTypes, $includingUnpublished);
  514.     }
  516.     /**
  517.      * Get a list of the sibling documents
  518.      *
  519.      * @param array $objectTypes
  520.      * @param bool $includingUnpublished
  521.      *
  522.      * @return array
  523.      */
  524.     public function getSiblings(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  525.     {
  526.         $cacheKey = $this->getListingCacheKey(func_get_args());
  528.         if (!isset($this->o_siblings[$cacheKey])) {
  529.             if ($this->getParentId()) {
  530.                 $list = new Listing();
  531.                 $list->setUnpublished($includingUnpublished);
  532.                 $list->addConditionParam('o_parentId = ?', $this->getParentId());
  533.                 if ($this->getId()) {
  534.                     $list->addConditionParam('o_id != ?', $this->getId());
  535.                 }
  536.                 $list->setOrderKey('o_key');
  537.                 $list->setObjectTypes($objectTypes);
  538.                 $list->setOrder('asc');
  539.                 $this->o_siblings[$cacheKey] = $list->load();
  540.                 $this->o_hasSiblings[$cacheKey] = (bool) count($this->o_siblings[$cacheKey]);
  541.             } else {
  542.                 $this->o_siblings[$cacheKey] = [];
  543.                 $this->o_hasSiblings[$cacheKey] = false;
  544.             }
  545.         }
  547.         return $this->o_siblings[$cacheKey];
  548.     }
  550.     /**
  551.      * Returns true if the object has at least one sibling
  552.      *
  553.      * @param array $objectTypes
  554.      * @param bool|null $includingUnpublished
  555.      *
  556.      * @return bool
  557.      */
  558.     public function hasSiblings($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  559.     {
  560.         $cacheKey = $this->getListingCacheKey(func_get_args());
  562.         if (isset($this->o_hasSiblings[$cacheKey])) {
  563.             return $this->o_hasSiblings[$cacheKey];
  564.         }
  566.         return $this->o_hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($objectTypes, $includingUnpublished);
  567.     }
  569.     /**
  570.      * enum('self','propagate') nullable
  571.      *
  572.      * @return string|null
  573.      */
  574.     public function getLocked()
  575.     {
  576.         return $this->o_locked;
  577.     }
  579.     /**
  580.      * enum('self','propagate') nullable
  581.      *
  582.      * @param string|null $o_locked
  583.      *
  584.      * @return $this
  585.      */
  586.     public function setLocked($o_locked)
  587.     {
  588.         $this->o_locked = $o_locked;
  590.         return $this;
  591.     }
  593.     /**
  594.      * @internal
  595.      *
  596.      * @throws \Exception
  597.      */
  598.     protected function doDelete()
  599.     {
  600.         // delete children
  601.         $children = $this->getChildren(self::$types, true);
  602.         if (count($children) > 0) {
  603.             foreach ($children as $child) {
  604.                 $child->delete();
  605.             }
  606.         }
  608.         // remove dependencies
  609.         $d = new Model\Dependency;
  610.         $d->cleanAllForElement($this);
  612.         // remove all properties
  613.         $this->getDao()->deleteAllProperties();
  614.     }
  616.     /**
  617.      * @throws \Exception
  618.      */
  619.     public function delete()
  620.     {
  621.         \Pimcore::getEventDispatcher()->dispatch(new DataObjectEvent($this), DataObjectEvents::PRE_DELETE);
  623.         $this->beginTransaction();
  625.         try {
  626.             $this->doDelete();
  627.             $this->getDao()->delete();
  629.             $this->commit();
  631.             //clear parent data from registry
  632.             $parentCacheKey = self::getCacheKey($this->getParentId());
  633.             if (Runtime::isRegistered($parentCacheKey)) {
  634.                 /** @var AbstractObject $parent * */
  635.                 $parent = Runtime::get($parentCacheKey);
  636.                 if ($parent instanceof self) {
  637.                     $parent->setChildren(null);
  638.                 }
  639.             }
  640.         } catch (\Exception $e) {
  641.             try {
  642.                 $this->rollBack();
  643.             } catch (\Exception $er) {
  644.                 // PDO adapter throws exceptions if rollback fails
  645.                 Logger::info($er);
  646.             }
  648.             $failureEvent = new DataObjectEvent($this);
  649.             $failureEvent->setArgument('exception', $e);
  650.             \Pimcore::getEventDispatcher()->dispatch($failureEvent, DataObjectEvents::POST_DELETE_FAILURE);
  652.             Logger::crit($e);
  654.             throw $e;
  655.         }
  657.         // empty object cache
  658.         $this->clearDependentCache();
  660.         //clear object from registry
  661.         Runtime::set(self::getCacheKey($this->getId()), null);
  663.         \Pimcore::getEventDispatcher()->dispatch(new DataObjectEvent($this), DataObjectEvents::POST_DELETE);
  664.     }
  666.     /**
  667.      * @return $this
  668.      *
  669.      * @throws \Exception
  670.      */
  671.     public function save()
  672.     {
  673.         // additional parameters (e.g. "versionNote" for the version note)
  674.         $params = [];
  675.         if (func_num_args() && is_array(func_get_arg(0))) {
  676.             $params = func_get_arg(0);
  677.         }
  679.         $isUpdate = false;
  680.         $differentOldPath = null;
  682.         try {
  683.             $isDirtyDetectionDisabled = self::isDirtyDetectionDisabled();
  684.             $preEvent = new DataObjectEvent($this, $params);
  685.             if ($this->getId()) {
  686.                 $isUpdate = true;
  687.                 \Pimcore::getEventDispatcher()->dispatch($preEvent, DataObjectEvents::PRE_UPDATE);
  688.             } else {
  689.                 self::disableDirtyDetection();
  690.                 \Pimcore::getEventDispatcher()->dispatch($preEvent, DataObjectEvents::PRE_ADD);
  691.             }
  693.             $params = $preEvent->getArguments();
  695.             $this->correctPath();
  697.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  698.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  699.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  700.             $maxRetries = 5;
  701.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  703.                 // be sure that unpublished objects in relations are saved also in frontend mode, eg. in importers, ...
  704.                 $hideUnpublishedBackup = self::getHideUnpublished();
  705.                 self::setHideUnpublished(false);
  707.                 $this->beginTransaction();
  709.                 try {
  710.                     if (!in_array($this->getType(), self::$types)) {
  711.                         throw new \Exception('invalid object type given: [' . $this->getType() . ']');
  712.                     }
  714.                     if (!$isUpdate) {
  715.                         $this->getDao()->create();
  716.                     }
  718.                     // get the old path from the database before the update is done
  719.                     $oldPath = null;
  720.                     if ($isUpdate) {
  721.                         $oldPath = $this->getDao()->getCurrentFullPath();
  722.                     }
  724.                     // if the old path is different from the new path, update all children
  725.                     // we need to do the update of the children's path before $this->update() because the
  726.                     // inheritance helper needs the correct paths of the children in InheritanceHelper::buildTree()
  727.                     $updatedChildren = [];
  728.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  729.                         $differentOldPath = $oldPath;
  730.                         $this->getDao()->updateWorkspaces();
  731.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  732.                     }
  734.                     $this->update($isUpdate, $params);
  736.                     self::setHideUnpublished($hideUnpublishedBackup);
  738.                     $this->commit();
  740.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  741.                 } catch (\Exception $e) {
  742.                     try {
  743.                         $this->rollBack();
  744.                     } catch (\Exception $er) {
  745.                         // PDO adapter throws exceptions if rollback fails
  746.                         Logger::info($er);
  747.                     }
  749.                     // set "HideUnpublished" back to the value it was originally
  750.                     self::setHideUnpublished($hideUnpublishedBackup);
  752.                     if ($e instanceof UniqueConstraintViolationException) {
  753.                         throw new Element\ValidationException('unique constraint violation', 0, $e);
  754.                     }
  756.                     if ($e instanceof RetryableException) {
  757.                         // we try to start the transaction $maxRetries times again (deadlocks, ...)
  758.                         if ($retries < ($maxRetries - 1)) {
  759.                             $run = $retries + 1;
  760.                             $waitTime = random_int(1, 5) * 100000; // microseconds
  761.                             Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  763.                             usleep($waitTime); // wait specified time until we restart the transaction
  764.                         } else {
  765.                             // if the transaction still fail after $maxRetries retries, we throw out the exception
  766.                             Logger::error('Finally giving up restarting the same transaction again and again, last message: ' . $e->getMessage());
  768.                             throw $e;
  769.                         }
  770.                     } else {
  771.                         throw $e;
  772.                     }
  773.                 }
  774.             }
  776.             $additionalTags = [];
  777.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  778.                 foreach ($updatedChildren as $objectId) {
  779.                     $tag = 'object_' . $objectId;
  780.                     $additionalTags[] = $tag;
  782.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  783.                     Runtime::set($tag, null);
  784.                 }
  785.             }
  786.             $this->clearDependentCache($additionalTags);
  788.             $postEvent = new DataObjectEvent($this, $params);
  789.             if ($isUpdate) {
  790.                 if ($differentOldPath) {
  791.                     $postEvent->setArgument('oldPath', $differentOldPath);
  792.                 }
  793.                 \Pimcore::getEventDispatcher()->dispatch($postEvent, DataObjectEvents::POST_UPDATE);
  794.             } else {
  795.                 self::setDisableDirtyDetection($isDirtyDetectionDisabled);
  796.                 \Pimcore::getEventDispatcher()->dispatch($postEvent, DataObjectEvents::POST_ADD);
  797.             }
  799.             return $this;
  800.         } catch (\Exception $e) {
  801.             $failureEvent = new DataObjectEvent($this, $params);
  802.             $failureEvent->setArgument('exception', $e);
  803.             if ($isUpdate) {
  804.                 \Pimcore::getEventDispatcher()->dispatch($failureEvent, DataObjectEvents::POST_UPDATE_FAILURE);
  805.             } else {
  806.                 \Pimcore::getEventDispatcher()->dispatch($failureEvent, DataObjectEvents::POST_ADD_FAILURE);
  807.             }
  809.             throw $e;
  810.         }
  811.     }
  813.     /**
  814.      * @internal
  815.      *
  816.      * @throws \Exception
  817.      */
  818.     protected function correctPath()
  819.     {
  820.         // set path
  821.         if ($this->getId() != 1) { // not for the root node
  823.             if (!Element\Service::isValidKey($this->getKey(), 'object')) {
  824.                 throw new \Exception('invalid key for object with id [ '.$this->getId().' ] key is: [' . $this->getKey() . ']');
  825.             }
  827.             if ($this->getParentId() == $this->getId()) {
  828.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  829.             }
  831.             $parent = DataObject::getById($this->getParentId());
  833.             if ($parent) {
  834.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  835.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  836.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath().'/'));
  837.             } else {
  838.                 // parent document doesn't exist anymore, set the parent to to root
  839.                 $this->setParentId(1);
  840.                 $this->setPath('/');
  841.             }
  843.             if (strlen($this->getKey()) < 1) {
  844.                 throw new \Exception('DataObject requires key');
  845.             }
  846.         } elseif ($this->getId() == 1) {
  847.             // some data in root node should always be the same
  848.             $this->setParentId(0);
  849.             $this->setPath('/');
  850.             $this->setKey('');
  851.             $this->setType(DataObject::OBJECT_TYPE_FOLDER);
  852.         }
  854.         if (Service::pathExists($this->getRealFullPath())) {
  855.             $duplicate = DataObject::getByPath($this->getRealFullPath());
  856.             if ($duplicate instanceof self && $duplicate->getId() != $this->getId()) {
  857.                 throw new \Exception('Duplicate full path [ '.$this->getRealFullPath().' ] - cannot save object');
  858.             }
  859.         }
  861.         $this->validatePathLength();
  862.     }
  864.     /**
  865.      * @internal
  866.      *
  867.      * @param bool|null $isUpdate
  868.      * @param array $params
  869.      *
  870.      * @throws \Exception
  871.      */
  872.     protected function update($isUpdate = null, $params = [])
  873.     {
  874.         $this->updateModificationInfos();
  876.         // save properties
  877.         $this->getProperties();
  878.         $this->getDao()->deleteAllProperties();
  880.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  881.             foreach ($this->getProperties() as $property) {
  882.                 if (!$property->getInherited()) {
  883.                     $property->setDao(null);
  884.                     $property->setCid($this->getId());
  885.                     $property->setCtype('object');
  886.                     $property->setCpath($this->getRealFullPath());
  887.                     $property->save();
  888.                 }
  889.             }
  890.         }
  892.         // save dependencies
  893.         $d = new Model\Dependency();
  894.         $d->setSourceType('object');
  895.         $d->setSourceId($this->getId());
  897.         foreach ($this->resolveDependencies() as $requirement) {
  898.             if ($requirement['id'] == $this->getId() && $requirement['type'] === 'object') {
  899.                 // dont't add a reference to yourself
  900.                 continue;
  901.             }
  903.             $d->addRequirement($requirement['id'], $requirement['type']);
  904.         }
  906.         $d->save();
  908.         //set object to registry
  909.         Runtime::set(self::getCacheKey($this->getId()), $this);
  910.     }
  912.     /**
  913.      * {@inheritdoc}
  914.      */
  915.     public function clearDependentCache($additionalTags = [])
  916.     {
  917.         self::clearDependentCacheByObjectId($this->getId(), $additionalTags);
  918.     }
  920.     /**
  921.      * @internal
  922.      *
  923.      * @param int $objectId
  924.      * @param array $additionalTags
  925.      */
  926.     public static function clearDependentCacheByObjectId($objectId, $additionalTags = [])
  927.     {
  928.         if (!$objectId) {
  929.             throw new \Exception('object ID missing');
  930.         }
  932.         try {
  933.             $tags = ['object_' . $objectId, 'object_properties', 'output'];
  934.             $tags = array_merge($tags, $additionalTags);
  936.             Cache::clearTags($tags);
  937.         } catch (\Exception $e) {
  938.             Logger::crit($e);
  939.         }
  940.     }
  942.     /**
  943.      * @internal
  944.      *
  945.      * @param int $index
  946.      */
  947.     public function saveIndex($index)
  948.     {
  949.         $this->getDao()->saveIndex($index);
  950.         $this->clearDependentCache();
  951.     }
  953.     /**
  954.      * @return string
  955.      */
  956.     public function getFullPath()
  957.     {
  958.         $path = $this->getPath() . $this->getKey();
  960.         return $path;
  961.     }
  963.     /**
  964.      * @return string
  965.      */
  966.     public function getRealPath()
  967.     {
  968.         return $this->getPath();
  969.     }
  971.     /**
  972.      * @return string
  973.      */
  974.     public function getRealFullPath()
  975.     {
  976.         return $this->getFullPath();
  977.     }
  979.     /**
  980.      * @return int|null
  981.      */
  982.     public function getId()
  983.     {
  984.         return $this->o_id;
  985.     }
  987.     /**
  988.      * @return int|null
  989.      */
  990.     public function getParentId()
  991.     {
  992.         // fall back to parent if no ID is set but we have a parent object
  993.         if (!$this->o_parentId && $this->o_parent) {
  994.             return $this->o_parent->getId();
  995.         }
  997.         return $this->o_parentId;
  998.     }
  1000.     /**
  1001.      * @return string
  1002.      */
  1003.     public function getType()
  1004.     {
  1005.         return $this->o_type;
  1006.     }
  1008.     /**
  1009.      * @return string|null
  1010.      */
  1011.     public function getKey()
  1012.     {
  1013.         return $this->o_key;
  1014.     }
  1016.     /**
  1017.      * @return string|null
  1018.      */
  1019.     public function getPath()
  1020.     {
  1021.         return $this->o_path;
  1022.     }
  1024.     /**
  1025.      * @return int
  1026.      */
  1027.     public function getIndex()
  1028.     {
  1029.         return $this->o_index;
  1030.     }
  1032.     /**
  1033.      * @return int|null
  1034.      */
  1035.     public function getCreationDate()
  1036.     {
  1037.         return $this->o_creationDate;
  1038.     }
  1040.     /**
  1041.      * @return int|null
  1042.      */
  1043.     public function getModificationDate()
  1044.     {
  1045.         return $this->o_modificationDate;
  1046.     }
  1048.     /**
  1049.      * @return int|null
  1050.      */
  1051.     public function getUserOwner()
  1052.     {
  1053.         return $this->o_userOwner;
  1054.     }
  1056.     /**
  1057.      * @return int
  1058.      */
  1059.     public function getUserModification()
  1060.     {
  1061.         return $this->o_userModification;
  1062.     }
  1064.     /**
  1065.      * @param int $o_id
  1066.      *
  1067.      * @return $this
  1068.      */
  1069.     public function setId($o_id)
  1070.     {
  1071.         $this->o_id = (int) $o_id;
  1073.         return $this;
  1074.     }
  1076.     /**
  1077.      * @param int $o_parentId
  1078.      *
  1079.      * @return $this
  1080.      */
  1081.     public function setParentId($o_parentId)
  1082.     {
  1083.         $o_parentId = (int) $o_parentId;
  1084.         if ($o_parentId != $this->o_parentId) {
  1085.             $this->markFieldDirty('o_parentId');
  1086.         }
  1087.         $this->o_parentId = $o_parentId;
  1088.         $this->o_parent = null;
  1089.         $this->o_siblings = [];
  1090.         $this->o_hasSiblings = [];
  1092.         return $this;
  1093.     }
  1095.     /**
  1096.      * @param string $o_type
  1097.      *
  1098.      * @return $this
  1099.      */
  1100.     public function setType($o_type)
  1101.     {
  1102.         $this->o_type = $o_type;
  1104.         return $this;
  1105.     }
  1107.     /**
  1108.      * @param string $o_key
  1109.      *
  1110.      * @return $this
  1111.      */
  1112.     public function setKey($o_key)
  1113.     {
  1114.         $this->o_key = (string)$o_key;
  1116.         return $this;
  1117.     }
  1119.     /**
  1120.      * @param string $o_path
  1121.      *
  1122.      * @return $this
  1123.      */
  1124.     public function setPath($o_path)
  1125.     {
  1126.         $this->o_path = $o_path;
  1128.         return $this;
  1129.     }
  1131.     /**
  1132.      * @param int $o_index
  1133.      *
  1134.      * @return $this
  1135.      */
  1136.     public function setIndex($o_index)
  1137.     {
  1138.         $this->o_index = (int) $o_index;
  1140.         return $this;
  1141.     }
  1143.     /**
  1144.      * @param string|null $childrenSortBy
  1145.      */
  1146.     public function setChildrenSortBy($childrenSortBy)
  1147.     {
  1148.         if ($this->o_childrenSortBy !== $childrenSortBy) {
  1149.             $this->o_children = [];
  1150.             $this->o_hasChildren = [];
  1151.         }
  1152.         $this->o_childrenSortBy = $childrenSortBy;
  1153.     }
  1155.     /**
  1156.      * @param int $o_creationDate
  1157.      *
  1158.      * @return $this
  1159.      */
  1160.     public function setCreationDate($o_creationDate)
  1161.     {
  1162.         $this->o_creationDate = (int) $o_creationDate;
  1164.         return $this;
  1165.     }
  1167.     /**
  1168.      * @param int $o_modificationDate
  1169.      *
  1170.      * @return $this
  1171.      */
  1172.     public function setModificationDate($o_modificationDate)
  1173.     {
  1174.         $this->markFieldDirty('o_modificationDate');
  1176.         $this->o_modificationDate = (int) $o_modificationDate;
  1178.         return $this;
  1179.     }
  1181.     /**
  1182.      * @param int $o_userOwner
  1183.      *
  1184.      * @return $this
  1185.      */
  1186.     public function setUserOwner($o_userOwner)
  1187.     {
  1188.         $this->o_userOwner = (int) $o_userOwner;
  1190.         return $this;
  1191.     }
  1193.     /**
  1194.      * @param int $o_userModification
  1195.      *
  1196.      * @return $this
  1197.      */
  1198.     public function setUserModification($o_userModification)
  1199.     {
  1200.         $this->markFieldDirty('o_userModification');
  1202.         $this->o_userModification = (int) $o_userModification;
  1204.         return $this;
  1205.     }
  1207.     /**
  1208.      * @param array|null $children
  1209.      * @param array $objectTypes
  1210.      * @param bool $includingUnpublished
  1211.      *
  1212.      * @return $this
  1213.      */
  1214.     public function setChildren($children, array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  1215.     {
  1216.         if ($children === null) {
  1217.             // unset all cached children
  1218.             $this->o_children = [];
  1219.             $this->o_hasChildren = [];
  1220.         } elseif (is_array($children)) {
  1221.             //default cache key
  1222.             $cacheKey = $this->getListingCacheKey([$objectTypes, $includingUnpublished]);
  1223.             $this->o_children[$cacheKey] = $children;
  1224.             $this->o_hasChildren[$cacheKey] = (bool) count($children);
  1225.         }
  1227.         return $this;
  1228.     }
  1230.     /**
  1231.      * @return self|null
  1232.      */
  1233.     public function getParent()
  1234.     {
  1235.         if ($this->o_parent === null) {
  1236.             $this->setParent(DataObject::getById($this->getParentId()));
  1237.         }
  1239.         return $this->o_parent;
  1240.     }
  1242.     /**
  1243.      * @param self|null $o_parent
  1244.      *
  1245.      * @return $this
  1246.      */
  1247.     public function setParent($o_parent)
  1248.     {
  1249.         $newParentId = $o_parent instanceof self ? $o_parent->getId() : 0;
  1250.         $this->setParentId($newParentId);
  1251.         $this->o_parent = $o_parent;
  1253.         return $this;
  1254.     }
  1256.     /**
  1257.      * @return Model\Property[]
  1258.      */
  1259.     public function getProperties()
  1260.     {
  1261.         if ($this->o_properties === null) {
  1262.             // try to get from cache
  1263.             $cacheKey = 'object_properties_' . $this->getId();
  1264.             $properties = Cache::load($cacheKey);
  1265.             if (!is_array($properties)) {
  1266.                 $properties = $this->getDao()->getProperties();
  1267.                 $elementCacheTag = $this->getCacheTag();
  1268.                 $cacheTags = ['object_properties' => 'object_properties', $elementCacheTag => $elementCacheTag];
  1269.                 Cache::save($properties, $cacheKey, $cacheTags);
  1270.             }
  1272.             $this->setProperties($properties);
  1273.         }
  1275.         return $this->o_properties;
  1276.     }
  1278.     /**
  1279.      * {@inheritdoc}
  1280.      */
  1281.     public function setProperties(?array $properties)
  1282.     {
  1283.         $this->o_properties = $properties;
  1285.         return $this;
  1286.     }
  1288.     /**
  1289.      * @param string $name
  1290.      * @param string $type
  1291.      * @param mixed $data
  1292.      * @param bool $inherited
  1293.      * @param bool $inheritable
  1294.      *
  1295.      * @return $this
  1296.      */
  1297.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1298.     {
  1299.         $this->getProperties();
  1301.         $property = new Model\Property();
  1302.         $property->setType($type);
  1303.         $property->setCid($this->getId());
  1304.         $property->setName($name);
  1305.         $property->setCtype('object');
  1306.         $property->setData($data);
  1307.         $property->setInherited($inherited);
  1308.         $property->setInheritable($inheritable);
  1310.         $this->o_properties[$name] = $property;
  1312.         return $this;
  1313.     }
  1315.     /**
  1316.      * @return string
  1317.      */
  1318.     public function getChildrenSortBy()
  1319.     {
  1320.         return $this->o_childrenSortBy ?? self::OBJECT_CHILDREN_SORT_BY_DEFAULT;
  1321.     }
  1323.     public function __sleep()
  1324.     {
  1325.         $parentVars = parent::__sleep();
  1327.         $blockedVars = ['o_hasChildren', 'o_versions', 'o_class', 'scheduledTasks', 'o_parent', 'omitMandatoryCheck'];
  1329.         if ($this->isInDumpState()) {
  1330.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  1331.             $blockedVars = array_merge($blockedVars, ['o_dirtyFields']);
  1332.             $this->removeInheritedProperties();
  1333.         } else {
  1334.             // this is if we want to cache the object
  1335.             $blockedVars = array_merge($blockedVars, ['o_children', 'o_properties']);
  1336.         }
  1338.         return array_diff($parentVars, $blockedVars);
  1339.     }
  1341.     public function __wakeup()
  1342.     {
  1343.         if ($this->isInDumpState() && !self::$doNotRestoreKeyAndPath) {
  1344.             // 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 )
  1345.             $originalElement = DataObject::getById($this->getId());
  1346.             if ($originalElement) {
  1347.                 $this->setKey($originalElement->getKey());
  1348.                 $this->setPath($originalElement->getRealPath());
  1349.             }
  1350.         }
  1352.         if ($this->isInDumpState() && $this->o_properties !== null) {
  1353.             $this->renewInheritedProperties();
  1354.         }
  1356.         $this->setInDumpState(false);
  1357.     }
  1359.     /**
  1360.      * @param string $method
  1361.      * @param array $args
  1362.      *
  1363.      * @return mixed
  1364.      *
  1365.      * @throws \Exception
  1366.      */
  1367.     public function __call($method, $args)
  1368.     {
  1370.         // compatibility mode (they do not have any set_oXyz() methods anymore)
  1371.         if (preg_match('/^(get|set)o_/i', $method)) {
  1372.             $newMethod = preg_replace('/^(get|set)o_/i', '$1', $method);
  1373.             if (method_exists($this, $newMethod)) {
  1374.                 $r = call_user_func_array([$this, $newMethod], $args);
  1376.                 return $r;
  1377.             }
  1378.         }
  1380.         return parent::__call($method, $args);
  1381.     }
  1383.     /**
  1384.      * @return bool
  1385.      */
  1386.     public static function doNotRestoreKeyAndPath()
  1387.     {
  1388.         return self::$doNotRestoreKeyAndPath;
  1389.     }
  1391.     /**
  1392.      * @param bool $doNotRestoreKeyAndPath
  1393.      */
  1394.     public static function setDoNotRestoreKeyAndPath($doNotRestoreKeyAndPath)
  1395.     {
  1396.         self::$doNotRestoreKeyAndPath = $doNotRestoreKeyAndPath;
  1397.     }
  1399.     /**
  1400.      * @param string $fieldName
  1401.      * @param string|null $language
  1402.      *
  1403.      * @throws \Exception
  1404.      *
  1405.      * @return mixed
  1406.      */
  1407.     public function get($fieldName, $language = null)
  1408.     {
  1409.         if (!$fieldName) {
  1410.             throw new \Exception('Field name must not be empty.');
  1411.         }
  1413.         return $this->{'get'.ucfirst($fieldName)}($language);
  1414.     }
  1416.     /**
  1417.      * @param string $fieldName
  1418.      * @param mixed $value
  1419.      * @param string|null $language
  1420.      *
  1421.      * @throws \Exception
  1422.      *
  1423.      * @return mixed
  1424.      */
  1425.     public function set($fieldName, $value, $language = null)
  1426.     {
  1427.         if (!$fieldName) {
  1428.             throw new \Exception('Field name must not be empty.');
  1429.         }
  1431.         return $this->{'set'.ucfirst($fieldName)}($value, $language);
  1432.     }
  1434.     /**
  1435.      * @internal
  1436.      *
  1437.      * @return bool
  1438.      */
  1439.     public static function isDirtyDetectionDisabled()
  1440.     {
  1441.         return self::$disableDirtyDetection;
  1442.     }
  1444.     /**
  1445.      * @internal
  1446.      *
  1447.      * @param bool $disableDirtyDetection
  1448.      */
  1449.     public static function setDisableDirtyDetection(bool $disableDirtyDetection)
  1450.     {
  1451.         self::$disableDirtyDetection = $disableDirtyDetection;
  1452.     }
  1454.     /**
  1455.      * @internal
  1456.      */
  1457.     public static function disableDirtyDetection()
  1458.     {
  1459.         self::setDisableDirtyDetection(true);
  1460.     }
  1462.     /**
  1463.      * @internal
  1464.      */
  1465.     public static function enableDirtyDetection()
  1466.     {
  1467.         self::setDisableDirtyDetection(false);
  1468.     }
  1470.     /**
  1471.      * @return int
  1472.      */
  1473.     public function getVersionCount(): int
  1474.     {
  1475.         return $this->o_versionCount ? $this->o_versionCount : 0;
  1476.     }
  1478.     /**
  1479.      * @param int|null $o_versionCount
  1480.      *
  1481.      * @return AbstractObject
  1482.      */
  1483.     public function setVersionCount(?int $o_versionCount): Element\ElementInterface
  1484.     {
  1485.         $this->o_versionCount = (int) $o_versionCount;
  1487.         return $this;
  1488.     }
  1490.     /**
  1491.      * @internal
  1492.      *
  1493.      * @param array $args
  1494.      *
  1495.      * @return string
  1496.      */
  1497.     protected function getListingCacheKey(array $args = [])
  1498.     {
  1499.         $objectTypes = $args[0] ?? [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER];
  1500.         $includingUnpublished = (bool)($args[1] ?? false);
  1502.         if (is_array($objectTypes)) {
  1503.             $objectTypes = implode('_', $objectTypes);
  1504.         }
  1506.         $cacheKey = $objectTypes . (!empty($includingUnpublished) ? '_' : '') . (string)$includingUnpublished;
  1508.         return $cacheKey;
  1509.     }
  1511.     /**
  1512.      * @param string | null $o_reverseSort
  1513.      *
  1514.      * @return AbstractObject
  1515.      */
  1516.     public function setChildrenSortOrder(?string $o_reverseSort): Element\ElementInterface
  1517.     {
  1518.         $this->o_childrenSortOrder = $o_reverseSort;
  1520.         return $this;
  1521.     }
  1523.     /**
  1524.      * @return string
  1525.      */
  1526.     public function getChildrenSortOrder(): string
  1527.     {
  1528.         return $this->o_childrenSortOrder ?? self::OBJECT_CHILDREN_SORT_ORDER_DEFAULT;
  1529.     }
  1531.     /**
  1532.      * load lazy loaded fields before cloning
  1533.      */
  1534.     public function __clone()
  1535.     {
  1536.         parent::__clone();
  1537.         $this->o_parent = null;
  1538.         // note that o_children is currently needed for the recycle bin
  1539.         $this->o_hasSiblings = [];
  1540.         $this->o_siblings = [];
  1541.     }
  1543.     /**
  1544.      * @param string $method
  1545.      * @param array $arguments
  1546.      *
  1547.      * @return mixed|Listing|null
  1548.      *
  1549.      * @throws \Exception
  1550.      */
  1551.     public static function __callStatic($method, $arguments)
  1552.     {
  1553.         $propertyName = lcfirst(preg_replace('/^getBy/i', '', $method));
  1555.         $realPropertyName = 'o_'.$propertyName;
  1557.         $db = \Pimcore\Db::get();
  1559.         if (in_array(strtolower($realPropertyName), self::$objectColumns)) {
  1560.             $arguments = array_pad($arguments, 4, 0);
  1561.             [$value, $limit, $offset, $objectTypes] = $arguments;
  1563.             $defaultCondition = $realPropertyName.' = '.Db::get()->quote($value).' ';
  1565.             $listConfig = [
  1566.                 'condition' => $defaultCondition,
  1567.             ];
  1569.             if (!is_array($limit)) {
  1570.                 if ($limit) {
  1571.                     $listConfig['limit'] = $limit;
  1572.                 }
  1573.                 if ($offset) {
  1574.                     $listConfig['offset'] = $offset;
  1575.                 }
  1576.             } else {
  1577.                 $listConfig = array_merge($listConfig, $limit);
  1578.                 $limitCondition = $limit['condition'] ?? '';
  1579.                 $listConfig['condition'] = $defaultCondition.$limitCondition;
  1580.             }
  1582.             $list = static::makeList($listConfig, $objectTypes);
  1584.             if (isset($listConfig['limit']) && $listConfig['limit'] == 1) {
  1585.                 $elements = $list->getObjects();
  1587.                 return isset($elements[0]) ? $elements[0] : null;
  1588.             }
  1590.             return $list;
  1591.         }
  1593.         // there is no property for the called method, so throw an exception
  1594.         Logger::error('Class: DataObject\\AbstractObject => call to undefined static method ' . $method);
  1596.         throw new \Exception('Call to undefined static method ' . $method . ' in class DataObject\\AbstractObject');
  1597.     }
  1599.     /**
  1600.      * @param  array  $listConfig
  1601.      * @param  mixed $objectTypes
  1602.      *
  1603.      * @return Listing
  1604.      *
  1605.      * @throws \Exception
  1606.      */
  1607.     protected static function makeList(array $listConfig, mixed $objectTypes): Listing
  1608.     {
  1609.         $list = static::getList($listConfig);
  1611.         // Check if variants, in addition to objects, to be fetched
  1612.         if (!empty($objectTypes)) {
  1613.             if (\array_diff($objectTypes, [static::OBJECT_TYPE_VARIANT, static::OBJECT_TYPE_OBJECT])) {
  1614.                 Logger::error('Class: DataObject\\AbstractObject => Unsupported object type in array ' . implode(',', $objectTypes));
  1616.                 throw new \Exception('Unsupported object type in array [' . implode(',', $objectTypes) . '] in class DataObject\\AbstractObject');
  1617.             }
  1619.             $list->setObjectTypes($objectTypes);
  1620.         }
  1622.         return $list;
  1623.     }
  1624. }