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

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @category   Pimcore
  12.  * @package    Object
  13.  *
  14.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  16.  */
  18. namespace Pimcore\Model\DataObject;
  20. use Doctrine\DBAL\Exception\RetryableException;
  21. use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
  22. use Pimcore\Cache;
  23. use Pimcore\Cache\Runtime;
  24. use Pimcore\Event\DataObjectEvents;
  25. use Pimcore\Event\Model\DataObjectEvent;
  26. use Pimcore\Logger;
  27. use Pimcore\Model;
  28. use Pimcore\Model\DataObject;
  29. use Pimcore\Model\Element;
  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. class AbstractObject extends Model\Element\AbstractElement
  40. {
  41.     const OBJECT_TYPE_FOLDER = 'folder';
  42.     const OBJECT_TYPE_OBJECT = 'object';
  43.     const OBJECT_TYPE_VARIANT = 'variant';
  45.     const OBJECT_CHILDREN_SORT_BY_DEFAULT = 'key';
  46.     const OBJECT_CHILDREN_SORT_BY_INDEX = 'index';
  47.     const OBJECT_CHILDREN_SORT_ORDER_DEFAULT = 'ASC';
  49.     /**
  50.      * @var bool
  51.      */
  52.     public static $doNotRestoreKeyAndPath = false;
  54.     /**
  55.      * possible types of a document
  56.      *
  57.      * @var array
  58.      */
  59.     public static $types = [self::OBJECT_TYPE_FOLDER, self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_VARIANT];
  61.     /**
  62.      * @var bool
  63.      */
  64.     private static $hideUnpublished = false;
  66.     /**
  67.      * @var bool
  68.      */
  69.     private static $getInheritedValues = false;
  71.     /**
  72.      * @var bool
  73.      */
  74.     protected static $disableDirtyDetection = false;
  76.     /**
  77.      * @var int
  78.      */
  79.     protected $o_id = 0;
  81.     /**
  82.      * @var int
  83.      */
  84.     protected $o_parentId;
  86.     /**
  87.      * @var self|null
  88.      */
  89.     protected $o_parent;
  91.     /**
  92.      * @var string
  93.      */
  94.     protected $o_type = 'object';
  96.     /**
  97.      * @var string
  98.      */
  99.     protected $o_key;
  101.     /**
  102.      * @var string
  103.      */
  104.     protected $o_path;
  106.     /**
  107.      * @var int
  108.      */
  109.     protected $o_index;
  111.     /**
  112.      * @var int
  113.      */
  114.     protected $o_creationDate;
  116.     /**
  117.      * @var int
  118.      */
  119.     protected $o_modificationDate;
  121.     /**
  122.      * @var int
  123.      */
  124.     protected $o_userOwner;
  126.     /**
  127.      * @var int
  128.      */
  129.     protected $o_userModification;
  131.     /**
  132.      * @var array
  133.      */
  134.     protected $o_properties = null;
  136.     /**
  137.      * @var bool[]
  138.      */
  139.     protected $o_hasChildren = [];
  141.     /**
  142.      * Contains a list of sibling documents
  143.      *
  144.      * @var array
  145.      */
  146.     protected $o_siblings = [];
  148.     /**
  149.      * Indicator if object has siblings or not
  150.      *
  151.      * @var bool[]
  152.      */
  153.     protected $o_hasSiblings = [];
  155.     /**
  156.      * @var array
  157.      */
  158.     protected $o_children = [];
  160.     /**
  161.      * @var string
  162.      */
  163.     protected $o_locked;
  165.     /**
  166.      * @var Model\Element\AdminStyle
  167.      */
  168.     protected $o_elementAdminStyle;
  170.     /**
  171.      * @var string
  172.      */
  173.     protected $o_childrenSortBy;
  175.     /**
  176.      * @var string
  177.      */
  178.     protected $o_childrenSortOrder;
  180.     /**
  181.      * @var int
  182.      */
  183.     protected $o_versionCount = 0;
  185.     private static function checkIfDeprecatedStaticCall($calledClass, $method)
  186.     {
  187.         if (self::class === $calledClass) {
  188.             @trigger_error(sprintf('Calling static methods on %s is deprecated, please use %s instead.', self::class, str_replace(self::class, DataObject::class, $method)), E_USER_DEPRECATED);
  189.         }
  190.     }
  192.     /**
  193.      * @static
  194.      *
  195.      * @return bool
  196.      */
  197.     public static function getHideUnpublished()
  198.     {
  199.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  201.         return self::$hideUnpublished;
  202.     }
  204.     /**
  205.      * @static
  206.      *
  207.      * @param bool $hideUnpublished
  208.      */
  209.     public static function setHideUnpublished($hideUnpublished)
  210.     {
  211.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  213.         self::$hideUnpublished = $hideUnpublished;
  214.     }
  216.     /**
  217.      * @static
  218.      *
  219.      * @return bool
  220.      */
  221.     public static function doHideUnpublished()
  222.     {
  223.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  225.         return self::$hideUnpublished;
  226.     }
  228.     /**
  229.      * @static
  230.      *
  231.      * @param bool $getInheritedValues
  232.      */
  233.     public static function setGetInheritedValues($getInheritedValues)
  234.     {
  235.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  237.         self::$getInheritedValues = $getInheritedValues;
  238.     }
  240.     /**
  241.      * @static
  242.      *
  243.      * @return bool
  244.      */
  245.     public static function getGetInheritedValues()
  246.     {
  247.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  249.         return self::$getInheritedValues;
  250.     }
  252.     /**
  253.      * @static
  254.      *
  255.      * @param Concrete $object
  256.      *
  257.      * @return bool
  258.      */
  259.     public static function doGetInheritedValues(Concrete $object = null)
  260.     {
  261.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  263.         if (self::$getInheritedValues && $object !== null) {
  264.             $class = $object->getClass();
  266.             return $class->getAllowInherit();
  267.         }
  269.         return self::$getInheritedValues;
  270.     }
  272.     /**
  273.      * get possible types
  274.      *
  275.      * @return array
  276.      */
  277.     public static function getTypes()
  278.     {
  279.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  281.         return self::$types;
  282.     }
  284.     /**
  285.      * Static helper to get an object by the passed ID
  286.      *
  287.      * @param int $id
  288.      * @param bool $force
  289.      *
  290.      * @return static|null
  291.      */
  292.     public static function getById($id, $force = false)
  293.     {
  294.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  296.         if (!is_numeric($id) || $id < 1) {
  297.             return null;
  298.         }
  300.         $id = intval($id);
  301.         $cacheKey = self::getCacheKey($id);
  303.         if (!$force && Runtime::isRegistered($cacheKey)) {
  304.             $object = Runtime::get($cacheKey);
  305.             if ($object && static::typeMatch($object)) {
  306.                 return $object;
  307.             }
  308.         }
  310.         try {
  311.             if ($force || !($object = Cache::load($cacheKey))) {
  312.                 $object = new Model\DataObject();
  313.                 $typeInfo = $object->getDao()->getTypeById($id);
  315.                 if (!empty($typeInfo['o_type']) && ($typeInfo['o_type'] == 'object' || $typeInfo['o_type'] == 'variant' || $typeInfo['o_type'] == 'folder')) {
  316.                     if ($typeInfo['o_type'] == 'folder') {
  317.                         $className = Folder::class;
  318.                     } else {
  319.                         $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($typeInfo['o_className']);
  320.                     }
  322.                     /** @var AbstractObject $object */
  323.                     $object = self::getModelFactory()->build($className);
  324.                     Runtime::set($cacheKey, $object);
  325.                     $object->getDao()->getById($id);
  326.                     $object->__setDataVersionTimestamp($object->getModificationDate());
  328.                     Service::recursiveResetDirtyMap($object);
  330.                     // force loading of relation data
  331.                     if ($object instanceof Concrete) {
  332.                         $object->__getRawRelationData();
  333.                     }
  335.                     Cache::save($object, $cacheKey);
  336.                 } else {
  337.                     throw new \Exception('No entry for object id ' . $id);
  338.                 }
  339.             } else {
  340.                 Runtime::set($cacheKey, $object);
  341.             }
  342.         } catch (\Exception $e) {
  343.             return null;
  344.         }
  346.         if (!$object || !static::typeMatch($object)) {
  347.             return null;
  348.         }
  350.         return $object;
  351.     }
  353.     /**
  354.      * @param string $path
  355.      * @param bool $force
  356.      *
  357.      * @return static|null
  358.      */
  359.     public static function getByPath($path, $force = false)
  360.     {
  361.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  363.         $path = Model\Element\Service::correctPath($path);
  365.         try {
  366.             $object = new static();
  367.             $object->getDao()->getByPath($path);
  369.             return static::getById($object->getId(), $force);
  370.         } catch (\Exception $e) {
  371.             return null;
  372.         }
  373.     }
  375.     /**
  376.      * @param array $config
  377.      *
  378.      * @return DataObject\Listing
  379.      *
  380.      * @throws \Exception
  381.      */
  382.     public static function getList($config = [])
  383.     {
  384.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  386.         $className = DataObject::class;
  387.         // get classname
  388.         if (!in_array(static::class, [__CLASS__, Concrete::class, Folder::class], true)) {
  389.             /** @var Concrete $tmpObject */
  390.             $tmpObject = new static();
  391.             if ($tmpObject instanceof Concrete) {
  392.                 $className = 'Pimcore\\Model\\DataObject\\' . ucfirst($tmpObject->getClassName());
  393.             }
  394.         }
  396.         if (is_array($config)) {
  397.             if (!empty($config['class'])) {
  398.                 $className = ltrim($config['class'], '\\');
  399.             }
  401.             if ($className) {
  402.                 $listClass = $className . '\\Listing';
  403.                 /** @var DataObject\Listing $list */
  404.                 $list = self::getModelFactory()->build($listClass);
  405.                 $list->setValues($config);
  407.                 return $list;
  408.             }
  409.         }
  411.         throw new \Exception('Unable to initiate list class - class not found or invalid configuration');
  412.     }
  414.     /**
  415.      * @param array $config
  416.      *
  417.      * @return int total count
  418.      */
  419.     public static function getTotalCount($config = [])
  420.     {
  421.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  423.         $list = static::getList($config);
  424.         $count = $list->getTotalCount();
  426.         return $count;
  427.     }
  429.     /**
  430.      * @param AbstractObject $object
  431.      *
  432.      * @return bool
  433.      */
  434.     protected static function typeMatch(AbstractObject $object)
  435.     {
  436.         return in_array(static::class, [Concrete::class, __CLASS__], true) || $object instanceof static;
  437.     }
  439.     /**
  440.      * @param array $objectTypes
  441.      * @param bool $includingUnpublished
  442.      *
  443.      * @return self[]
  444.      */
  445.     public function getChildren(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  446.     {
  447.         $cacheKey = $this->getListingCacheKey(func_get_args());
  449.         if (!isset($this->o_children[$cacheKey])) {
  450.             $list = new Listing();
  451.             $list->setUnpublished($includingUnpublished);
  452.             $list->setCondition('o_parentId = ?', $this->getId());
  453.             $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  454.             $list->setOrder($this->getChildrenSortOrder());
  455.             $list->setObjectTypes($objectTypes);
  456.             $this->o_children[$cacheKey] = $list->load();
  457.             $this->o_hasChildren[$cacheKey] = (bool) count($this->o_children[$cacheKey]);
  458.         }
  460.         return $this->o_children[$cacheKey];
  461.     }
  463.     /**
  464.      * Quick test if there are children
  465.      *
  466.      * @param array $objectTypes
  467.      * @param bool|null $includingUnpublished
  468.      *
  469.      * @return bool
  470.      */
  471.     public function hasChildren($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  472.     {
  473.         $cacheKey = $this->getListingCacheKey(func_get_args());
  475.         if (isset($this->o_hasChildren[$cacheKey])) {
  476.             return $this->o_hasChildren[$cacheKey];
  477.         }
  479.         return $this->o_hasChildren[$cacheKey] = $this->getDao()->hasChildren($objectTypes, $includingUnpublished);
  480.     }
  482.     /**
  483.      * Get a list of the sibling documents
  484.      *
  485.      * @param array $objectTypes
  486.      * @param bool $includingUnpublished
  487.      *
  488.      * @return array
  489.      */
  490.     public function getSiblings(array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  491.     {
  492.         $cacheKey = $this->getListingCacheKey(func_get_args());
  494.         if (!isset($this->o_siblings[$cacheKey])) {
  495.             $list = new Listing();
  496.             $list->setUnpublished($includingUnpublished);
  497.             // string conversion because parentId could be 0
  498.             $list->addConditionParam('o_parentId = ?', (string)$this->getParentId());
  499.             $list->addConditionParam('o_id != ?', $this->getId());
  500.             $list->setOrderKey('o_key');
  501.             $list->setObjectTypes($objectTypes);
  502.             $list->setOrder('asc');
  503.             $this->o_siblings[$cacheKey] = $list->load();
  504.             $this->o_hasSiblings[$cacheKey] = (bool) count($this->o_siblings[$cacheKey]);
  505.         }
  507.         return $this->o_siblings[$cacheKey];
  508.     }
  510.     /**
  511.      * Returns true if the object has at least one sibling
  512.      *
  513.      * @param array $objectTypes
  514.      * @param bool|null $includingUnpublished
  515.      *
  516.      * @return bool
  517.      */
  518.     public function hasSiblings($objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = null)
  519.     {
  520.         $cacheKey = $this->getListingCacheKey(func_get_args());
  522.         if (isset($this->o_hasSiblings[$cacheKey])) {
  523.             return $this->o_hasSiblings[$cacheKey];
  524.         }
  526.         return $this->o_hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($objectTypes, $includingUnpublished);
  527.     }
  529.     /**
  530.      * enum('self','propagate') nullable
  531.      *
  532.      * @return string|null
  533.      */
  534.     public function getLocked()
  535.     {
  536.         return $this->o_locked;
  537.     }
  539.     /**
  540.      * enum('self','propagate') nullable
  541.      *
  542.      * @param string|null $o_locked
  543.      *
  544.      * @return $this
  545.      */
  546.     public function setLocked($o_locked)
  547.     {
  548.         $this->o_locked = $o_locked;
  550.         return $this;
  551.     }
  553.     /**
  554.      * @throws \Exception
  555.      */
  556.     protected function doDelete()
  557.     {
  558.         // delete children
  559.         $children = $this->getChildren([self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER, self::OBJECT_TYPE_VARIANT], true);
  560.         if (count($children) > 0) {
  561.             foreach ($children as $child) {
  562.                 $child->delete();
  563.             }
  564.         }
  566.         // remove dependencies
  567.         $d = new Model\Dependency;
  568.         $d->cleanAllForElement($this);
  570.         // remove all properties
  571.         $this->getDao()->deleteAllProperties();
  573.         // remove all permissions
  574.         $this->getDao()->deleteAllPermissions();
  575.     }
  577.     /**
  578.      * @throws \Exception
  579.      */
  580.     public function delete()
  581.     {
  582.         \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::PRE_DELETE, new DataObjectEvent($this));
  584.         $this->beginTransaction();
  586.         try {
  587.             $this->doDelete();
  588.             $this->getDao()->delete();
  590.             $this->commit();
  592.             //clear parent data from registry
  593.             $parentCacheKey = self::getCacheKey($this->getParentId());
  594.             if (Runtime::isRegistered($parentCacheKey)) {
  595.                 /** @var AbstractObject $parent * */
  596.                 $parent = Runtime::get($parentCacheKey);
  597.                 if ($parent instanceof self) {
  598.                     $parent->setChildren(null);
  599.                 }
  600.             }
  601.         } catch (\Exception $e) {
  602.             $this->rollBack();
  603.             $failureEvent = new DataObjectEvent($this);
  604.             $failureEvent->setArgument('exception', $e);
  605.             \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_DELETE_FAILURE, $failureEvent);
  607.             Logger::crit($e);
  608.             throw $e;
  609.         }
  611.         // empty object cache
  612.         $this->clearDependentCache();
  614.         //clear object from registry
  615.         Runtime::set(self::getCacheKey($this->getId()), null);
  617.         \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_DELETE, new DataObjectEvent($this));
  618.     }
  620.     /**
  621.      * @return $this
  622.      *
  623.      * @throws \Exception
  624.      */
  625.     public function save()
  626.     {
  627.         // additional parameters (e.g. "versionNote" for the version note)
  628.         $params = [];
  629.         if (func_num_args() && is_array(func_get_arg(0))) {
  630.             $params = func_get_arg(0);
  631.         }
  633.         $isUpdate = false;
  634.         $differentOldPath = null;
  636.         try {
  637.             $isDirtyDetectionDisabled = self::isDirtyDetectionDisabled();
  638.             $preEvent = new DataObjectEvent($this, $params);
  639.             if ($this->getId()) {
  640.                 $isUpdate = true;
  641.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::PRE_UPDATE, $preEvent);
  642.             } else {
  643.                 self::disableDirtyDetection();
  644.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::PRE_ADD, $preEvent);
  645.             }
  647.             $params = $preEvent->getArguments();
  649.             $this->correctPath();
  651.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  652.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  653.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  654.             $maxRetries = 5;
  655.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  657.                 // be sure that unpublished objects in relations are saved also in frontend mode, eg. in importers, ...
  658.                 $hideUnpublishedBackup = self::getHideUnpublished();
  659.                 self::setHideUnpublished(false);
  661.                 $this->beginTransaction();
  663.                 try {
  664.                     if (!in_array($this->getType(), self::$types)) {
  665.                         throw new \Exception('invalid object type given: [' . $this->getType() . ']');
  666.                     }
  668.                     if (!$isUpdate) {
  669.                         $this->getDao()->create();
  670.                     }
  672.                     // get the old path from the database before the update is done
  673.                     $oldPath = null;
  674.                     if ($isUpdate) {
  675.                         $oldPath = $this->getDao()->getCurrentFullPath();
  676.                     }
  678.                     // if the old path is different from the new path, update all children
  679.                     // we need to do the update of the children's path before $this->update() because the
  680.                     // inheritance helper needs the correct paths of the children in InheritanceHelper::buildTree()
  681.                     $updatedChildren = [];
  682.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  683.                         $differentOldPath = $oldPath;
  684.                         $this->getDao()->updateWorkspaces();
  685.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  686.                     }
  688.                     $this->update($isUpdate, $params);
  690.                     self::setHideUnpublished($hideUnpublishedBackup);
  692.                     $this->commit();
  693.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  694.                 } catch (\Exception $e) {
  695.                     try {
  696.                         $this->rollBack();
  697.                     } catch (\Exception $er) {
  698.                         // PDO adapter throws exceptions if rollback fails
  699.                         Logger::info($er);
  700.                     }
  702.                     // set "HideUnpublished" back to the value it was originally
  703.                     self::setHideUnpublished($hideUnpublishedBackup);
  705.                     if ($e instanceof UniqueConstraintViolationException) {
  706.                         throw new Element\ValidationException('unique constraint violation', 0, $e);
  707.                     }
  709.                     if ($e instanceof RetryableException) {
  710.                         // we try to start the transaction $maxRetries times again (deadlocks, ...)
  711.                         if ($retries < ($maxRetries - 1)) {
  712.                             $run = $retries + 1;
  713.                             $waitTime = random_int(1, 5) * 100000; // microseconds
  714.                             Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  716.                             usleep($waitTime); // wait specified time until we restart the transaction
  717.                         } else {
  718.                             // if the transaction still fail after $maxRetries retries, we throw out the exception
  719.                             Logger::error('Finally giving up restarting the same transaction again and again, last message: ' . $e->getMessage());
  720.                             throw $e;
  721.                         }
  722.                     } else {
  723.                         throw $e;
  724.                     }
  725.                 }
  726.             }
  728.             $additionalTags = [];
  729.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  730.                 foreach ($updatedChildren as $objectId) {
  731.                     $tag = 'object_' . $objectId;
  732.                     $additionalTags[] = $tag;
  734.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  735.                     Runtime::set($tag, null);
  736.                 }
  737.             }
  738.             $this->clearDependentCache($additionalTags);
  740.             if ($isUpdate) {
  741.                 $updateEvent = new DataObjectEvent($this);
  742.                 if ($differentOldPath) {
  743.                     $updateEvent->setArgument('oldPath', $differentOldPath);
  744.                 }
  745.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_UPDATE, $updateEvent);
  746.             } else {
  747.                 self::setDisableDirtyDetection($isDirtyDetectionDisabled);
  748.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_ADD, new DataObjectEvent($this));
  749.             }
  751.             return $this;
  752.         } catch (\Exception $e) {
  753.             $failureEvent = new DataObjectEvent($this);
  754.             $failureEvent->setArgument('exception', $e);
  755.             if ($isUpdate) {
  756.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_UPDATE_FAILURE, $failureEvent);
  757.             } else {
  758.                 \Pimcore::getEventDispatcher()->dispatch(DataObjectEvents::POST_ADD_FAILURE, $failureEvent);
  759.             }
  761.             throw $e;
  762.         }
  763.     }
  765.     public function correctPath()
  766.     {
  767.         // set path
  768.         if ($this->getId() != 1) { // not for the root node
  770.             if (!Element\Service::isValidKey($this->getKey(), 'object')) {
  771.                 throw new \Exception('invalid key for object with id [ '.$this->getId().' ] key is: [' . $this->getKey() . ']');
  772.             }
  774.             if ($this->getParentId() == $this->getId()) {
  775.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  776.             }
  778.             $parent = DataObject::getById($this->getParentId());
  780.             if ($parent) {
  781.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  782.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  783.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath().'/'));
  784.             } else {
  785.                 // parent document doesn't exist anymore, set the parent to to root
  786.                 $this->setParentId(1);
  787.                 $this->setPath('/');
  788.             }
  790.             if (strlen($this->getKey()) < 1) {
  791.                 throw new \Exception('DataObject requires key');
  792.             }
  793.         } elseif ($this->getId() == 1) {
  794.             // some data in root node should always be the same
  795.             $this->setParentId(0);
  796.             $this->setPath('/');
  797.             $this->setKey('');
  798.             $this->setType('folder');
  799.         }
  801.         if (Service::pathExists($this->getRealFullPath())) {
  802.             $duplicate = DataObject::getByPath($this->getRealFullPath());
  803.             if ($duplicate instanceof self && $duplicate->getId() != $this->getId()) {
  804.                 throw new \Exception('Duplicate full path [ '.$this->getRealFullPath().' ] - cannot save object');
  805.             }
  806.         }
  808.         $this->validatePathLength();
  809.     }
  811.     /**
  812.      * @param bool|null $isUpdate
  813.      * @param array $params
  814.      *
  815.      * @throws \Exception
  816.      */
  817.     protected function update($isUpdate = null, $params = [])
  818.     {
  819.         $this->updateModificationInfos();
  821.         // save properties
  822.         $this->getProperties();
  823.         $this->getDao()->deleteAllProperties();
  825.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  826.             foreach ($this->getProperties() as $property) {
  827.                 if (!$property->getInherited()) {
  828.                     $property->setDao(null);
  829.                     $property->setCid($this->getId());
  830.                     $property->setCtype('object');
  831.                     $property->setCpath($this->getRealFullPath());
  832.                     $property->save();
  833.                 }
  834.             }
  835.         }
  837.         // save dependencies
  838.         $d = new Model\Dependency();
  839.         $d->setSourceType('object');
  840.         $d->setSourceId($this->getId());
  842.         foreach ($this->resolveDependencies() as $requirement) {
  843.             if ($requirement['id'] == $this->getId() && $requirement['type'] === 'object') {
  844.                 // dont't add a reference to yourself
  845.                 continue;
  846.             }
  848.             $d->addRequirement($requirement['id'], $requirement['type']);
  849.         }
  851.         $d->save();
  853.         //set object to registry
  854.         Runtime::set(self::getCacheKey($this->getId()), $this);
  855.     }
  857.     /**
  858.      * @param array $additionalTags
  859.      */
  860.     public function clearDependentCache($additionalTags = [])
  861.     {
  862.         self::clearDependentCacheByObjectId($this->getId(), $additionalTags);
  863.     }
  865.     /**
  866.      * @internal
  867.      *
  868.      * @param int $objectId
  869.      * @param array $additionalTags
  870.      */
  871.     public static function clearDependentCacheByObjectId($objectId, $additionalTags = [])
  872.     {
  873.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  875.         if (!$objectId) {
  876.             throw new \Exception('object ID missing');
  877.         }
  879.         try {
  880.             $tags = ['object_' . $objectId, 'object_properties', 'output'];
  881.             $tags = array_merge($tags, $additionalTags);
  883.             Cache::clearTags($tags);
  884.         } catch (\Exception $e) {
  885.             Logger::crit($e);
  886.         }
  887.     }
  889.     /**
  890.      * @param int $index
  891.      */
  892.     public function saveIndex($index)
  893.     {
  894.         $this->getDao()->saveIndex($index);
  895.         $this->clearDependentCache();
  896.     }
  898.     /**
  899.      * @return string
  900.      */
  901.     public function getFullPath()
  902.     {
  903.         $path = $this->getPath() . $this->getKey();
  905.         return $path;
  906.     }
  908.     /**
  909.      * @return string
  910.      */
  911.     public function getRealPath()
  912.     {
  913.         return $this->getPath();
  914.     }
  916.     /**
  917.      * @return string
  918.      */
  919.     public function getRealFullPath()
  920.     {
  921.         return $this->getFullPath();
  922.     }
  924.     /**
  925.      * @return int
  926.      */
  927.     public function getId()
  928.     {
  929.         return $this->o_id;
  930.     }
  932.     /**
  933.      * @return int
  934.      */
  935.     public function getParentId()
  936.     {
  937.         // fall back to parent if no ID is set but we have a parent object
  938.         if (!$this->o_parentId && $this->o_parent) {
  939.             return $this->o_parent->getId();
  940.         }
  942.         return $this->o_parentId;
  943.     }
  945.     /**
  946.      * @return string
  947.      */
  948.     public function getType()
  949.     {
  950.         return $this->o_type;
  951.     }
  953.     /**
  954.      * @return string
  955.      */
  956.     public function getKey()
  957.     {
  958.         return $this->o_key;
  959.     }
  961.     /**
  962.      * @return string path
  963.      */
  964.     public function getPath()
  965.     {
  966.         return $this->o_path;
  967.     }
  969.     /**
  970.      * @return int
  971.      */
  972.     public function getIndex()
  973.     {
  974.         return $this->o_index;
  975.     }
  977.     /**
  978.      * @return int
  979.      */
  980.     public function getCreationDate()
  981.     {
  982.         return $this->o_creationDate;
  983.     }
  985.     /**
  986.      * @return int
  987.      */
  988.     public function getModificationDate()
  989.     {
  990.         return $this->o_modificationDate;
  991.     }
  993.     /**
  994.      * @return int
  995.      */
  996.     public function getUserOwner()
  997.     {
  998.         return $this->o_userOwner;
  999.     }
  1001.     /**
  1002.      * @return int
  1003.      */
  1004.     public function getUserModification()
  1005.     {
  1006.         return $this->o_userModification;
  1007.     }
  1009.     /**
  1010.      * @param int $o_id
  1011.      *
  1012.      * @return $this
  1013.      */
  1014.     public function setId($o_id)
  1015.     {
  1016.         $this->o_id = (int) $o_id;
  1018.         return $this;
  1019.     }
  1021.     /**
  1022.      * @param int $o_parentId
  1023.      *
  1024.      * @return $this
  1025.      */
  1026.     public function setParentId($o_parentId)
  1027.     {
  1028.         $o_parentId = (int) $o_parentId;
  1029.         if ($o_parentId != $this->o_parentId) {
  1030.             $this->markFieldDirty('o_parentId');
  1031.         }
  1032.         $this->o_parentId = $o_parentId;
  1033.         $this->o_parent = null;
  1034.         $this->o_siblings = [];
  1035.         $this->o_hasSiblings = [];
  1037.         return $this;
  1038.     }
  1040.     /**
  1041.      * @param string $o_type
  1042.      *
  1043.      * @return $this
  1044.      */
  1045.     public function setType($o_type)
  1046.     {
  1047.         $this->o_type = $o_type;
  1049.         return $this;
  1050.     }
  1052.     /**
  1053.      * @param string $o_key
  1054.      *
  1055.      * @return $this
  1056.      */
  1057.     public function setKey($o_key)
  1058.     {
  1059.         $this->o_key = $o_key;
  1061.         return $this;
  1062.     }
  1064.     /**
  1065.      * @param string $o_path
  1066.      *
  1067.      * @return $this
  1068.      */
  1069.     public function setPath($o_path)
  1070.     {
  1071.         $this->o_path = $o_path;
  1073.         return $this;
  1074.     }
  1076.     /**
  1077.      * @param int $o_index
  1078.      *
  1079.      * @return $this
  1080.      */
  1081.     public function setIndex($o_index)
  1082.     {
  1083.         $this->o_index = (int) $o_index;
  1085.         return $this;
  1086.     }
  1088.     /**
  1089.      * @param string|null $childrenSortBy
  1090.      */
  1091.     public function setChildrenSortBy($childrenSortBy)
  1092.     {
  1093.         if ($this->o_childrenSortBy !== $childrenSortBy) {
  1094.             $this->o_children = [];
  1095.             $this->o_hasChildren = [];
  1096.         }
  1097.         $this->o_childrenSortBy = $childrenSortBy;
  1098.     }
  1100.     /**
  1101.      * @param int $o_creationDate
  1102.      *
  1103.      * @return $this
  1104.      */
  1105.     public function setCreationDate($o_creationDate)
  1106.     {
  1107.         $this->o_creationDate = (int) $o_creationDate;
  1109.         return $this;
  1110.     }
  1112.     /**
  1113.      * @param int $o_modificationDate
  1114.      *
  1115.      * @return $this
  1116.      */
  1117.     public function setModificationDate($o_modificationDate)
  1118.     {
  1119.         $this->markFieldDirty('o_modificationDate');
  1121.         $this->o_modificationDate = (int) $o_modificationDate;
  1123.         return $this;
  1124.     }
  1126.     /**
  1127.      * @param int $o_userOwner
  1128.      *
  1129.      * @return $this
  1130.      */
  1131.     public function setUserOwner($o_userOwner)
  1132.     {
  1133.         $this->o_userOwner = (int) $o_userOwner;
  1135.         return $this;
  1136.     }
  1138.     /**
  1139.      * @param int $o_userModification
  1140.      *
  1141.      * @return $this
  1142.      */
  1143.     public function setUserModification($o_userModification)
  1144.     {
  1145.         $this->markFieldDirty('o_userModification');
  1147.         $this->o_userModification = (int) $o_userModification;
  1149.         return $this;
  1150.     }
  1152.     /**
  1153.      * @param array|null $children
  1154.      * @param array $objectTypes
  1155.      * @param bool $includingUnpublished
  1156.      *
  1157.      * @return $this
  1158.      */
  1159.     public function setChildren($children, array $objectTypes = [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER], $includingUnpublished = false)
  1160.     {
  1161.         if ($children === null) {
  1162.             // unset all cached children
  1163.             $this->o_children = [];
  1164.             $this->o_hasChildren = [];
  1165.         } elseif (is_array($children)) {
  1166.             //default cache key
  1167.             $cacheKey = $this->getListingCacheKey([$objectTypes, $includingUnpublished]);
  1168.             $this->o_children[$cacheKey] = $children;
  1169.             $this->o_hasChildren[$cacheKey] = (bool) count($children);
  1170.         }
  1172.         return $this;
  1173.     }
  1175.     /**
  1176.      * @return self
  1177.      */
  1178.     public function getParent()
  1179.     {
  1180.         if ($this->o_parent === null) {
  1181.             $this->setParent(DataObject::getById($this->getParentId()));
  1182.         }
  1184.         return $this->o_parent;
  1185.     }
  1187.     /**
  1188.      * @param self $o_parent
  1189.      *
  1190.      * @return $this
  1191.      */
  1192.     public function setParent($o_parent)
  1193.     {
  1194.         $newParentId = $o_parent instanceof self ? $o_parent->getId() : 0;
  1195.         $this->setParentId($newParentId);
  1196.         $this->o_parent = $o_parent;
  1198.         return $this;
  1199.     }
  1201.     /**
  1202.      * @return Model\Property[]
  1203.      */
  1204.     public function getProperties()
  1205.     {
  1206.         if ($this->o_properties === null) {
  1207.             // try to get from cache
  1208.             $cacheKey = 'object_properties_' . $this->getId();
  1209.             $properties = Cache::load($cacheKey);
  1210.             if (!is_array($properties)) {
  1211.                 $properties = $this->getDao()->getProperties();
  1212.                 $elementCacheTag = $this->getCacheTag();
  1213.                 $cacheTags = ['object_properties' => 'object_properties', $elementCacheTag => $elementCacheTag];
  1214.                 Cache::save($properties, $cacheKey, $cacheTags);
  1215.             }
  1217.             $this->setProperties($properties);
  1218.         }
  1220.         return $this->o_properties;
  1221.     }
  1223.     /**
  1224.      * @param Model\Property[] $o_properties
  1225.      *
  1226.      * @return $this
  1227.      */
  1228.     public function setProperties($o_properties)
  1229.     {
  1230.         $this->o_properties = $o_properties;
  1232.         return $this;
  1233.     }
  1235.     /**
  1236.      * @param string $name
  1237.      * @param string $type
  1238.      * @param mixed $data
  1239.      * @param bool $inherited
  1240.      * @param bool $inheritable
  1241.      *
  1242.      * @return $this
  1243.      */
  1244.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1245.     {
  1246.         $this->getProperties();
  1248.         $property = new Model\Property();
  1249.         $property->setType($type);
  1250.         $property->setCid($this->getId());
  1251.         $property->setName($name);
  1252.         $property->setCtype('object');
  1253.         $property->setData($data);
  1254.         $property->setInherited($inherited);
  1255.         $property->setInheritable($inheritable);
  1257.         $this->o_properties[$name] = $property;
  1259.         return $this;
  1260.     }
  1262.     /**
  1263.      * @deprecated since 6.4.1, use AdminEvents.RESOLVE_ELEMENT_ADMIN_STYLE event instead
  1264.      *
  1265.      * @return Model\Element\AdminStyle
  1266.      */
  1267.     public function getElementAdminStyle()
  1268.     {
  1269.         if (empty($this->o_elementAdminStyle)) {
  1270.             $this->o_elementAdminStyle = new Model\Element\AdminStyle($this);
  1271.         }
  1273.         return $this->o_elementAdminStyle;
  1274.     }
  1276.     /**
  1277.      * @return string
  1278.      */
  1279.     public function getChildrenSortBy()
  1280.     {
  1281.         return $this->o_childrenSortBy ?? self::OBJECT_CHILDREN_SORT_BY_DEFAULT;
  1282.     }
  1284.     public function __sleep()
  1285.     {
  1286.         $parentVars = parent::__sleep();
  1288.         $blockedVars = ['o_hasChildren', 'o_versions', 'o_class', 'scheduledTasks', 'o_parent', 'omitMandatoryCheck'];
  1290.         if ($this->isInDumpState()) {
  1291.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  1292.             $blockedVars = array_merge($blockedVars, ['o_dirtyFields']);
  1293.             $this->removeInheritedProperties();
  1294.         } else {
  1295.             // this is if we want to cache the object
  1296.             $blockedVars = array_merge($blockedVars, ['o_children', 'o_properties']);
  1297.         }
  1299.         return array_diff($parentVars, $blockedVars);
  1300.     }
  1302.     public function __wakeup()
  1303.     {
  1304.         if ($this->isInDumpState() && !self::$doNotRestoreKeyAndPath) {
  1305.             // 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 )
  1306.             $originalElement = DataObject::getById($this->getId());
  1307.             if ($originalElement) {
  1308.                 $this->setKey($originalElement->getKey());
  1309.                 $this->setPath($originalElement->getRealPath());
  1310.             }
  1311.         }
  1313.         if ($this->isInDumpState() && $this->o_properties !== null) {
  1314.             $this->renewInheritedProperties();
  1315.         }
  1317.         $this->setInDumpState(false);
  1318.     }
  1320.     public function removeInheritedProperties()
  1321.     {
  1322.         $myProperties = $this->getProperties();
  1324.         if ($myProperties) {
  1325.             foreach ($this->getProperties() as $name => $property) {
  1326.                 if ($property->getInherited()) {
  1327.                     unset($myProperties[$name]);
  1328.                 }
  1329.             }
  1330.         }
  1332.         $this->setProperties($myProperties);
  1333.     }
  1335.     public function renewInheritedProperties()
  1336.     {
  1337.         $this->removeInheritedProperties();
  1339.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  1340.         $cacheKey = self::getCacheKey($this->getId());
  1341.         if (!Runtime::isRegistered($cacheKey)) {
  1342.             Runtime::set($cacheKey, $this);
  1343.         }
  1345.         $myProperties = $this->getProperties();
  1346.         $inheritedProperties = $this->getDao()->getProperties(true);
  1347.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  1348.     }
  1350.     /**
  1351.      * @param string $method
  1352.      * @param array $args
  1353.      *
  1354.      * @return mixed
  1355.      *
  1356.      * @throws \Exception
  1357.      */
  1358.     public function __call($method, $args)
  1359.     {
  1361.         // compatibility mode (they do not have any set_oXyz() methods anymore)
  1362.         if (preg_match('/^(get|set)o_/i', $method)) {
  1363.             $newMethod = preg_replace('/^(get|set)o_/i', '$1', $method);
  1364.             if (method_exists($this, $newMethod)) {
  1365.                 $r = call_user_func_array([$this, $newMethod], $args);
  1367.                 return $r;
  1368.             }
  1369.         }
  1371.         return parent::__call($method, $args);
  1372.     }
  1374.     /**
  1375.      * @return bool
  1376.      */
  1377.     public static function doNotRestoreKeyAndPath()
  1378.     {
  1379.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1381.         return self::$doNotRestoreKeyAndPath;
  1382.     }
  1384.     /**
  1385.      * @param bool $doNotRestoreKeyAndPath
  1386.      */
  1387.     public static function setDoNotRestoreKeyAndPath($doNotRestoreKeyAndPath)
  1388.     {
  1389.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1391.         self::$doNotRestoreKeyAndPath = $doNotRestoreKeyAndPath;
  1392.     }
  1394.     /**
  1395.      * @param string $fieldName
  1396.      * @param string|null $language
  1397.      *
  1398.      * @throws \Exception
  1399.      *
  1400.      * @return mixed
  1401.      */
  1402.     public function get($fieldName, $language = null)
  1403.     {
  1404.         if (!$fieldName) {
  1405.             throw new \Exception('Field name must not be empty.');
  1406.         }
  1408.         return $this->{'get'.ucfirst($fieldName)}($language);
  1409.     }
  1411.     /**
  1412.      * @param string $fieldName
  1413.      * @param mixed $value
  1414.      * @param string|null $language
  1415.      *
  1416.      * @throws \Exception
  1417.      *
  1418.      * @return mixed
  1419.      */
  1420.     public function set($fieldName, $value, $language = null)
  1421.     {
  1422.         if (!$fieldName) {
  1423.             throw new \Exception('Field name must not be empty.');
  1424.         }
  1426.         return $this->{'set'.ucfirst($fieldName)}($value, $language);
  1427.     }
  1429.     /**
  1430.      * @return bool
  1431.      */
  1432.     public static function isDirtyDetectionDisabled()
  1433.     {
  1434.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1436.         return self::$disableDirtyDetection;
  1437.     }
  1439.     /**
  1440.      * @param bool $disableDirtyDetection
  1441.      */
  1442.     public static function setDisableDirtyDetection(bool $disableDirtyDetection)
  1443.     {
  1444.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1446.         self::$disableDirtyDetection = $disableDirtyDetection;
  1447.     }
  1449.     /**
  1450.      * Disables the dirty detection
  1451.      */
  1452.     public static function disableDirtyDetection()
  1453.     {
  1454.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1456.         self::setDisableDirtyDetection(true);
  1457.     }
  1459.     /**
  1460.      * Enables the dirty detection
  1461.      */
  1462.     public static function enableDirtyDetection()
  1463.     {
  1464.         self::checkIfDeprecatedStaticCall(get_called_class(), __METHOD__);
  1466.         self::setDisableDirtyDetection(false);
  1467.     }
  1469.     /**
  1470.      * @return int
  1471.      */
  1472.     public function getVersionCount(): int
  1473.     {
  1474.         return $this->o_versionCount ? $this->o_versionCount : 0;
  1475.     }
  1477.     /**
  1478.      * @param int|null $o_versionCount
  1479.      *
  1480.      * @return AbstractObject
  1481.      */
  1482.     public function setVersionCount(?int $o_versionCount): Element\ElementInterface
  1483.     {
  1484.         $this->o_versionCount = (int) $o_versionCount;
  1486.         return $this;
  1487.     }
  1489.     protected function getListingCacheKey(array $args = [])
  1490.     {
  1491.         $objectTypes = $args[0] ?? [self::OBJECT_TYPE_OBJECT, self::OBJECT_TYPE_FOLDER];
  1492.         $includingUnpublished = (bool)($args[1] ?? false);
  1494.         if (is_array($objectTypes)) {
  1495.             $objectTypes = implode('_', $objectTypes);
  1496.         }
  1498.         $cacheKey = $objectTypes . (!empty($includingUnpublished) ? '_' : '') . (string)$includingUnpublished;
  1500.         return $cacheKey;
  1501.     }
  1503.     /**
  1504.      * @param string | null $o_reverseSort
  1505.      *
  1506.      * @return AbstractObject
  1507.      */
  1508.     public function setChildrenSortOrder(?string $o_reverseSort): Element\ElementInterface
  1509.     {
  1510.         $this->o_childrenSortOrder = $o_reverseSort;
  1512.         return $this;
  1513.     }
  1515.     /**
  1516.      * @return string
  1517.      */
  1518.     public function getChildrenSortOrder(): string
  1519.     {
  1520.         return $this->o_childrenSortOrder ?? self::OBJECT_CHILDREN_SORT_ORDER_DEFAULT;
  1521.     }
  1523.     /**
  1524.      * load lazy loaded fields before cloning
  1525.      */
  1526.     public function __clone()
  1527.     {
  1528.         parent::__clone();
  1529.         $this->o_parent = null;
  1530.         // note that o_children is currently needed for the recycle bin
  1531.         $this->o_hasSiblings = [];
  1532.         $this->o_siblings = [];
  1533.     }
  1534. }