vendor/pimcore/pimcore/models/Element/AbstractElement.php line 331

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\Element;
  18. use Pimcore\Cache;
  19. use Pimcore\Cache\RuntimeCache;
  20. use Pimcore\Event\AdminEvents;
  21. use Pimcore\Event\Model\ElementEvent;
  22. use Pimcore\Event\Traits\RecursionBlockingEventDispatchHelperTrait;
  23. use Pimcore\Model;
  24. use Pimcore\Model\Element\Traits\DirtyIndicatorTrait;
  25. use Pimcore\Model\User;
  27. /**
  28.  * @method Model\Document\Dao|Model\Asset\Dao|Model\DataObject\AbstractObject\Dao getDao()
  29.  */
  30. abstract class AbstractElement extends Model\AbstractModel implements ElementInterface, ElementDumpStateInterface, DirtyIndicatorInterface
  31. {
  32.     use ElementDumpStateTrait;
  33.     use DirtyIndicatorTrait;
  34.     use RecursionBlockingEventDispatchHelperTrait;
  36.     /**
  37.      * @internal
  38.      *
  39.      * @var Model\Dependency|null
  40.      */
  41.     protected $dependencies;
  43.     /**
  44.      * @internal
  45.      *
  46.      * @var int
  47.      */
  48.     protected $__dataVersionTimestamp = null;
  50.     /**
  51.      * @internal
  52.      *
  53.      * @var string|null
  54.      */
  55.     protected $path;
  57.     /**
  58.      * @internal
  59.      *
  60.      * @var array|null
  61.      */
  62.     protected ?array $properties = null;
  64.     /**
  65.      * @internal
  66.      *
  67.      * @var bool
  68.      */
  69.     public static $doNotRestoreKeyAndPath = false;
  71.     /**
  72.      * @internal
  73.      *
  74.      * @var int|null
  75.      */
  76.     protected ?int $id = null;
  78.     /**
  79.      * @return string|null
  80.      */
  81.     public function getPath()
  82.     {
  83.         return $this->path;
  84.     }
  86.     /**
  87.      * @param string $path
  88.      *
  89.      * @return $this
  90.      */
  91.     public function setPath($path)
  92.     {
  93.         $this->path = (string) $path;
  95.         return $this;
  96.     }
  98.     /**
  99.      * @internal
  100.      *
  101.      * @var int|null
  102.      */
  103.     protected ?int $creationDate = null;
  105.     /**
  106.      * @internal
  107.      *
  108.      * @var int|null
  109.      */
  110.     protected $modificationDate;
  112.     /**
  113.      * @internal
  114.      *
  115.      * @var int
  116.      */
  117.     protected $versionCount = 0;
  119.     /**
  120.      * @internal
  121.      *
  122.      * @var int|null
  123.      */
  124.     protected ?int $userOwner = null;
  126.     /**
  127.      * @internal
  128.      *
  129.      * @var string|null
  130.      */
  131.     protected ?string $locked = null;
  133.     /**
  134.      * @internal
  135.      *
  136.      * @var int|null
  137.      */
  138.     protected ?int $userModification = null;
  140.     /**
  141.      * @internal
  142.      *
  143.      * @var int|null
  144.      */
  145.     protected ?int $parentId = null;
  147.     /**
  148.      * @return int|null
  149.      */
  150.     public function getParentId()
  151.     {
  152.         return $this->parentId;
  153.     }
  155.     /**
  156.      * @param int $parentId
  157.      *
  158.      * @return $this
  159.      */
  160.     public function setParentId($parentId)
  161.     {
  162.         $parentId = (int) $parentId;
  163.         $this->parentId = $parentId;
  164.         $this->parent = null;
  166.         return $this;
  167.     }
  169.     /**
  170.      * @return int|null
  171.      */
  172.     public function getUserModification()
  173.     {
  174.         return $this->userModification;
  175.     }
  177.     /**
  178.      * @param int $userModification
  179.      *
  180.      * @return $this
  181.      */
  182.     public function setUserModification($userModification)
  183.     {
  184.         $this->markFieldDirty('userModification');
  185.         $this->userModification = (int) $userModification;
  187.         return $this;
  188.     }
  190.     /**
  191.      * @return int|null
  192.      */
  193.     public function getCreationDate()
  194.     {
  195.         return $this->creationDate;
  196.     }
  198.     /**
  199.      * @param int $creationDate
  200.      *
  201.      * @return $this
  202.      */
  203.     public function setCreationDate($creationDate)
  204.     {
  205.         $this->creationDate = (int) $creationDate;
  207.         return $this;
  208.     }
  210.     /**
  211.      * @return int|null
  212.      */
  213.     public function getModificationDate()
  214.     {
  215.         return $this->modificationDate;
  216.     }
  218.     /**
  219.      * @param int $modificationDate
  220.      *
  221.      * @return $this
  222.      */
  223.     public function setModificationDate($modificationDate)
  224.     {
  225.         if ($this->modificationDate != (int)$modificationDate) {
  226.             $this->markFieldDirty('modificationDate');
  227.             $this->modificationDate = (int)$modificationDate;
  228.         }
  230.         return $this;
  231.     }
  233.     /**
  234.      * @return int|null
  235.      */
  236.     public function getUserOwner()
  237.     {
  238.         return $this->userOwner;
  239.     }
  241.     /**
  242.      * @param int $userOwner
  243.      *
  244.      * @return $this
  245.      */
  246.     public function setUserOwner($userOwner)
  247.     {
  248.         $this->userOwner = (int) $userOwner;
  250.         return $this;
  251.     }
  253.     /**
  254.      * enum('self','propagate') nullable
  255.      *
  256.      * @return string|null
  257.      */
  258.     public function getLocked()
  259.     {
  260.         if (empty($this->locked)) {
  261.             return null;
  262.         }
  264.         return $this->locked;
  265.     }
  267.     /**
  268.      * enum('self','propagate') nullable
  269.      *
  270.      * @param string|null $locked
  271.      *
  272.      * @return $this
  273.      */
  274.     public function setLocked($locked)
  275.     {
  276.         $this->locked = $locked;
  278.         return $this;
  279.     }
  281.     /**
  282.      * @return int|null
  283.      */
  284.     public function getId()
  285.     {
  286.         return $this->id;
  287.     }
  289.     /**
  290.      * @param int|null $id
  291.      *
  292.      * @return $this
  293.      */
  294.     public function setId($id)
  295.     {
  296.         $this->id = $id ? (int)$id : null;
  298.         return $this;
  299.     }
  301.     /**
  302.      * @var self|null
  303.      */
  304.     protected $parent = null;
  306.     /**
  307.      * @return self|null
  308.      */
  309.     public function getParent()
  310.     {
  311.         if ($this->parent === null) {
  312.             $parent = Service::getElementById(Service::getElementType($this), $this->getParentId());
  313.             $this->setParent($parent);
  314.         }
  316.         return $this->parent;
  317.     }
  319.     /**
  320.      * @return Model\Property[]
  321.      */
  322.     public function getProperties()
  323.     {
  324.         $type = Service::getElementType($this);
  326.         if ($this->properties === null) {
  327.             // try to get from cache
  328.             $cacheKey = $type . '_properties_' . $this->getId();
  329.             $properties = Cache::load($cacheKey);
  330.             if (!is_array($properties)) {
  331.                 $properties = $this->getDao()->getProperties();
  332.                 $elementCacheTag = $this->getCacheTag();
  333.                 $cacheTags = [$type . '_properties' => $type . '_properties', $elementCacheTag => $elementCacheTag];
  334.                 Cache::save($properties, $cacheKey, $cacheTags);
  335.             }
  337.             $this->setProperties($properties);
  338.         }
  340.         return $this->properties;
  341.     }
  343.     /**
  344.      * {@inheritdoc}
  345.      */
  346.     public function setProperties(?array $properties)
  347.     {
  348.         $this->properties = $properties;
  350.         return $this;
  351.     }
  353.     /**
  354.      * @param string $name
  355.      * @param string $type
  356.      * @param mixed $data
  357.      * @param bool $inherited
  358.      * @param bool $inheritable
  359.      *
  360.      * @return $this
  361.      */
  362.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  363.     {
  364.         $this->getProperties();
  366.         $property = new Model\Property();
  367.         $property->setType($type);
  368.         $property->setCid($this->getId());
  369.         $property->setName($name);
  370.         $property->setCtype(Service::getElementType($this));
  371.         $property->setData($data);
  372.         $property->setInherited($inherited);
  373.         $property->setInheritable($inheritable);
  375.         $this->properties[$name] = $property;
  377.         return $this;
  378.     }
  380.     /**
  381.      * @internal
  382.      */
  383.     protected function updateModificationInfos()
  384.     {
  385.         if (Model\Version::isEnabled() === true) {
  386.             $this->setVersionCount($this->getDao()->getVersionCountForUpdate() + 1);
  387.         }
  389.         if ($this->getVersionCount() > 4200000000) {
  390.             $this->setVersionCount(1);
  391.         }
  393.         $modificationDateKey = 'modificationDate';
  394.         if (!$this->isFieldDirty($modificationDateKey)) {
  395.             $updateTime = time();
  396.             $this->setModificationDate($updateTime);
  397.         }
  399.         if (!$this->getCreationDate()) {
  400.             $this->setCreationDate($this->getModificationDate());
  401.         }
  403.         // auto assign user if possible, if not changed explicitly, if no user present, use ID=0 which represents the "system" user
  404.         $userModificationKey = 'userModification';
  405.         if (!$this->isFieldDirty($userModificationKey)) {
  406.             $userId = 0;
  407.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  408.             if ($user instanceof User) {
  409.                 $userId = $user->getId();
  410.             }
  411.             $this->setUserModification($userId);
  412.         }
  414.         if ($this->getUserOwner() === null) {
  415.             $this->setUserOwner($this->getUserModification());
  416.         }
  417.     }
  419.     /**
  420.      * {@inheritdoc}
  421.      */
  422.     public function getProperty($name, $asContainer = false)
  423.     {
  424.         $properties = $this->getProperties();
  425.         if ($this->hasProperty($name)) {
  426.             if ($asContainer) {
  427.                 return $properties[$name];
  428.             } else {
  429.                 return $properties[$name]->getData();
  430.             }
  431.         }
  433.         return null;
  434.     }
  436.     /**
  437.      * {@inheritdoc}
  438.      */
  439.     public function hasProperty($name)
  440.     {
  441.         $properties = $this->getProperties();
  443.         return array_key_exists($name, $properties);
  444.     }
  446.     /**
  447.      * @param string $name
  448.      */
  449.     public function removeProperty($name)
  450.     {
  451.         $properties = $this->getProperties();
  452.         unset($properties[$name]);
  453.         $this->setProperties($properties);
  454.     }
  456.     /**
  457.      * @return int
  458.      */
  459.     public function getVersionCount(): int
  460.     {
  461.         return $this->versionCount ? $this->versionCount : 0;
  462.     }
  464.     /**
  465.      * @param int|null $versionCount
  466.      *
  467.      * @return $this
  468.      */
  469.     public function setVersionCount(?int $versionCount): ElementInterface
  470.     {
  471.         $this->versionCount = (int) $versionCount;
  473.         return $this;
  474.     }
  476.     /**
  477.      * {@inheritdoc}
  478.      */
  479.     public function getCacheTag()
  480.     {
  481.         $elementType = Service::getElementType($this);
  483.         return Service::getElementCacheTag($elementType, $this->getId());
  484.     }
  486.     /**
  487.      * @internal
  488.      *
  489.      * @param string|int $id
  490.      *
  491.      * @return string
  492.      */
  493.     protected static function getCacheKey($id): string
  494.     {
  495.         $elementType = Service::getElementTypeByClassName(static::class);
  497.         return Service::getElementCacheTag($elementType, $id);
  498.     }
  500.     /**
  501.      * {@inheritdoc}
  502.      */
  503.     public function getCacheTags(array $tags = []): array
  504.     {
  505.         $tags[$this->getCacheTag()] = $this->getCacheTag();
  507.         return $tags;
  508.     }
  510.     /**
  511.      * Resolves the dependencies of the element and returns an array of them - Used by update()
  512.      *
  513.      * @internal
  514.      *
  515.      * @return array
  516.      */
  517.     protected function resolveDependencies(): array
  518.     {
  519.         $dependencies = [[]];
  521.         // check for properties
  522.         if (method_exists($this, 'getProperties')) {
  523.             foreach ($this->getProperties() as $property) {
  524.                 $dependencies[] = $property->resolveDependencies();
  525.             }
  526.         }
  528.         return array_merge(...$dependencies);
  529.     }
  531.     /**
  532.      * {@inheritdoc}
  533.      */
  534.     public function isLocked()
  535.     {
  536.         if ($this->getLocked()) {
  537.             return true;
  538.         }
  540.         // check for inherited
  541.         return $this->getDao()->isLocked();
  542.     }
  544.     /**
  545.      * @param User|null $user
  546.      *
  547.      * @return array
  548.      *
  549.      * @throws \Exception
  550.      *
  551.      * @internal
  552.      */
  553.     public function getUserPermissions(?User $user = null)
  554.     {
  555.         $baseClass = Service::getBaseClassNameForElement($this);
  556.         $workspaceClass = '\\Pimcore\\Model\\User\\Workspace\\' . $baseClass;
  557.         /** @var Model\AbstractModel $dummy */
  558.         $dummy = new $workspaceClass();
  559.         $vars = $dummy->getObjectVars();
  560.         $ignored = ['userId', 'cid', 'cpath', 'dao'];
  561.         $permissions = [];
  563.         $columns = array_diff(array_keys($vars), $ignored);
  564.         $defaultValue = 0;
  566.         if (null === $user) {
  567.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  568.         }
  570.         if ((!$user && php_sapi_name() === 'cli') || $user?->isAdmin()) {
  571.             $defaultValue = 1;
  572.         }
  574.         foreach ($columns as $name) {
  575.             $permissions[$name] = $defaultValue;
  576.         }
  578.         if (!$user || $user->isAdmin() || !$user->isAllowed(Service::getElementType($this) . 's')) {
  579.             return $permissions;
  580.         }
  582.         $permissions = $this->getDao()->areAllowed($columns, $user);
  584.         foreach ($permissions as $type => $isAllowed) {
  585.             $event = new ElementEvent($this, ['isAllowed' => $isAllowed, 'permissionType' => $type, 'user' => $user]);
  586.             \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::ELEMENT_PERMISSION_IS_ALLOWED);
  588.             $permissions[$type] = $event->getArgument('isAllowed');
  589.         }
  591.         return $permissions;
  592.     }
  594.     /**
  595.      * {@inheritdoc}
  596.      */
  597.     public function isAllowed($type, ?User $user = null)
  598.     {
  599.         if (null === $user) {
  600.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  601.         }
  603.         if (!$user) {
  604.             if (php_sapi_name() === 'cli') {
  605.                 return true;
  606.             }
  608.             return false;
  609.         }
  611.         //everything is allowed for admin
  612.         if ($user->isAdmin()) {
  613.             return true;
  614.         }
  616.         if (!$user->isAllowed(Service::getElementType($this) . 's')) {
  617.             return false;
  618.         }
  619.         $isAllowed = $this->getDao()->isAllowed($type, $user);
  621.         $event = new ElementEvent($this, ['isAllowed' => $isAllowed, 'permissionType' => $type, 'user' => $user]);
  622.         \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::ELEMENT_PERMISSION_IS_ALLOWED);
  624.         return (bool) $event->getArgument('isAllowed');
  625.     }
  627.     /**
  628.      * @internal
  629.      */
  630.     public function unlockPropagate()
  631.     {
  632.         $type = Service::getElementType($this);
  634.         $ids = $this->getDao()->unlockPropagate();
  636.         // invalidate cache items
  637.         foreach ($ids as $id) {
  638.             $element = Service::getElementById($type, $id);
  639.             if ($element) {
  640.                 $element->clearDependentCache();
  641.             }
  642.         }
  643.     }
  645.     /**
  646.      * @internal
  647.      *
  648.      * @throws \Exception
  649.      */
  650.     protected function validatePathLength()
  651.     {
  652.         if (mb_strlen($this->getRealFullPath()) > 765) {
  653.             throw new \Exception("Full path is limited to 765 characters, reduce the length of your parent's path");
  654.         }
  655.     }
  657.     /**
  658.      * {@inheritdoc}
  659.      */
  660.     public function __toString()
  661.     {
  662.         return $this->getFullPath();
  663.     }
  665.     /**
  666.      * @return int
  667.      */
  668.     public function __getDataVersionTimestamp()
  669.     {
  670.         return $this->__dataVersionTimestamp;
  671.     }
  673.     /**
  674.      * @param int $_dataVersionTimestamp
  675.      */
  676.     public function __setDataVersionTimestamp($_dataVersionTimestamp)
  677.     {
  678.         $this->__dataVersionTimestamp = $_dataVersionTimestamp;
  679.     }
  681.     /**
  682.      * {@inheritdoc}
  683.      */
  684.     public function __isBasedOnLatestData()
  685.     {
  686.         return $this->getDao()->__isBasedOnLatestData();
  687.     }
  689.     /**
  690.      * @internal
  691.      *
  692.      * @param string|null $versionNote
  693.      * @param bool $saveOnlyVersion
  694.      * @param bool $saveStackTrace
  695.      * @param bool $isAutoSave
  696.      *
  697.      * @return Model\Version
  698.      *
  699.      * @throws \Exception
  700.      */
  701.     protected function doSaveVersion($versionNote = null, $saveOnlyVersion = true, $saveStackTrace = true, $isAutoSave = false)
  702.     {
  703.         $version = null;
  705.         if ($isAutoSave) {
  706.             $list = new Model\Version\Listing();
  707.             $list->setLoadAutoSave(true);
  708.             $list->setCondition('autoSave = 1 AND cid = ? AND cType = ? AND userId = ? ', [$this->getId(), Service::getElementType($this), $this->getUserModification()]);
  709.             $version = $list->current();
  710.         }
  712.         if (!$version) {
  713.             /** @var Model\Version $version */
  714.             $version = self::getModelFactory()->build(Model\Version::class);
  715.         }
  717.         $version->setCid($this->getId());
  718.         $version->setCtype(Service::getElementType($this));
  719.         $version->setDate($this->getModificationDate());
  720.         $version->setUserId($this->getUserModification());
  721.         $version->setData($this);
  722.         $version->setNote($versionNote);
  723.         $version->setGenerateStackTrace($saveStackTrace);
  724.         $version->setAutoSave($isAutoSave);
  726.         if ($saveOnlyVersion) {
  727.             $versionCount = $this->getDao()->getVersionCountForUpdate();
  728.             $versionCount++;
  729.         } else {
  730.             $versionCount = $this->getVersionCount();
  731.         }
  733.         $version->setVersionCount($versionCount);
  734.         $version->save();
  736.         return $version;
  737.     }
  739.     /**
  740.      * {@inheritdoc}
  741.      */
  742.     public function getDependencies()
  743.     {
  744.         if (!$this->dependencies) {
  745.             $this->dependencies = Model\Dependency::getBySourceId($this->getId(), Service::getElementType($this));
  746.         }
  748.         return $this->dependencies;
  749.     }
  751.     /**
  752.      * {@inheritdoc}
  753.      */
  754.     public function getScheduledTasks()
  755.     {
  756.         return [];
  757.     }
  759.     /**
  760.      * {@inheritdoc}
  761.      */
  762.     public function getVersions()
  763.     {
  764.         return [];
  765.     }
  767.     /**
  768.      * @internal
  769.      *
  770.      * @return string[]
  771.      */
  772.     protected function getBlockedVars(): array
  773.     {
  774.         return ['dependencies', 'parent'];
  775.     }
  777.     /**
  778.      * {@inheritdoc}
  779.      */
  780.     public function __sleep()
  781.     {
  782.         if ($this->isInDumpState()) {
  783.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  784.             $this->removeInheritedProperties();
  785.         }
  787.         return array_diff(parent::__sleep(), $this->getBlockedVars());
  788.     }
  790.     public function __wakeup()
  791.     {
  792.         if ($this->isInDumpState()) {
  793.             // 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 )
  794.             $originalElement = static::getById($this->getId());
  796.             if ($originalElement && !self::$doNotRestoreKeyAndPath) {
  797.                 // set key and path for DataObject and Document (assets have different wakeup call)
  798.                 $this->setKey($originalElement->getKey());
  799.                 $this->setPath($originalElement->getRealPath());
  800.             }
  801.         }
  803.         if ($this->isInDumpState() && $this->properties !== null) {
  804.             $this->renewInheritedProperties();
  805.         }
  807.         $this->setInDumpState(false);
  808.     }
  810.     public function __clone()
  811.     {
  812.         parent::__clone();
  813.         $this->dependencies = null;
  814.     }
  816.     /**
  817.      * @internal
  818.      *
  819.      * @param int $userId
  820.      */
  821.     public function deleteAutoSaveVersions($userId = null)
  822.     {
  823.         $list = new Model\Version\Listing();
  824.         $list->setLoadAutoSave(true);
  825.         if ($userId) {
  826.             $list->setCondition('`ctype` = ? AND cid = ? AND `autoSave` = 1 AND userId = ?', [Service::getElementType($this), $this->getId(), $userId]);
  827.         } else {
  828.             $list->setCondition('`ctype` = ? AND cid = ? AND `autoSave` = 1', [Service::getElementType($this), $this->getId()]);
  829.         }
  831.         foreach ($list->load() as $version) {
  832.             $version->delete();
  833.         }
  834.     }
  836.     /**
  837.      * @internal
  838.      */
  839.     protected function removeInheritedProperties()
  840.     {
  841.         $myProperties = $this->getProperties();
  843.         if ($myProperties) {
  844.             foreach ($this->getProperties() as $name => $property) {
  845.                 if ($property->getInherited()) {
  846.                     unset($myProperties[$name]);
  847.                 }
  848.             }
  849.         }
  851.         $this->setProperties($myProperties);
  852.     }
  854.     /**
  855.      * @internal
  856.      */
  857.     protected function renewInheritedProperties()
  858.     {
  859.         $this->removeInheritedProperties();
  861.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  862.         $cacheKey = self::getCacheKey($this->getId());
  863.         if (!RuntimeCache::isRegistered($cacheKey)) {
  864.             RuntimeCache::set($cacheKey, $this);
  865.         }
  867.         $myProperties = $this->getProperties();
  868.         $inheritedProperties = $this->getDao()->getProperties(true);
  869.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  870.     }
  871. }