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

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.         $this->markFieldDirty('modificationDate');
  227.         $this->modificationDate = (int) $modificationDate;
  229.         return $this;
  230.     }
  232.     /**
  233.      * @return int|null
  234.      */
  235.     public function getUserOwner()
  236.     {
  237.         return $this->userOwner;
  238.     }
  240.     /**
  241.      * @param int $userOwner
  242.      *
  243.      * @return $this
  244.      */
  245.     public function setUserOwner($userOwner)
  246.     {
  247.         $this->userOwner = (int) $userOwner;
  249.         return $this;
  250.     }
  252.     /**
  253.      * enum('self','propagate') nullable
  254.      *
  255.      * @return string|null
  256.      */
  257.     public function getLocked()
  258.     {
  259.         if (empty($this->locked)) {
  260.             return null;
  261.         }
  263.         return $this->locked;
  264.     }
  266.     /**
  267.      * enum('self','propagate') nullable
  268.      *
  269.      * @param string|null $locked
  270.      *
  271.      * @return $this
  272.      */
  273.     public function setLocked($locked)
  274.     {
  275.         $this->locked = $locked;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return int|null
  282.      */
  283.     public function getId()
  284.     {
  285.         return $this->id;
  286.     }
  288.     /**
  289.      * @param int|null $id
  290.      *
  291.      * @return $this
  292.      */
  293.     public function setId($id)
  294.     {
  295.         $this->id = $id ? (int)$id : null;
  297.         return $this;
  298.     }
  300.     /**
  301.      * @var self|null
  302.      */
  303.     protected $parent = null;
  305.     /**
  306.      * @return self|null
  307.      */
  308.     public function getParent()
  309.     {
  310.         if ($this->parent === null) {
  311.             $parent = Service::getElementById(Service::getElementType($this), $this->getParentId());
  312.             $this->setParent($parent);
  313.         }
  315.         return $this->parent;
  316.     }
  318.     /**
  319.      * @return Model\Property[]
  320.      */
  321.     public function getProperties()
  322.     {
  323.         $type = Service::getElementType($this);
  325.         if ($this->properties === null) {
  326.             // try to get from cache
  327.             $cacheKey = $type . '_properties_' . $this->getId();
  328.             $properties = Cache::load($cacheKey);
  329.             if (!is_array($properties)) {
  330.                 $properties = $this->getDao()->getProperties();
  331.                 $elementCacheTag = $this->getCacheTag();
  332.                 $cacheTags = [$type . '_properties' => $type . '_properties', $elementCacheTag => $elementCacheTag];
  333.                 Cache::save($properties, $cacheKey, $cacheTags);
  334.             }
  336.             $this->setProperties($properties);
  337.         }
  339.         return $this->properties;
  340.     }
  342.     /**
  343.      * {@inheritdoc}
  344.      */
  345.     public function setProperties(?array $properties)
  346.     {
  347.         $this->properties = $properties;
  349.         return $this;
  350.     }
  352.     /**
  353.      * @param string $name
  354.      * @param string $type
  355.      * @param mixed $data
  356.      * @param bool $inherited
  357.      * @param bool $inheritable
  358.      *
  359.      * @return $this
  360.      */
  361.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  362.     {
  363.         $this->getProperties();
  365.         $property = new Model\Property();
  366.         $property->setType($type);
  367.         $property->setCid($this->getId());
  368.         $property->setName($name);
  369.         $property->setCtype(Service::getElementType($this));
  370.         $property->setData($data);
  371.         $property->setInherited($inherited);
  372.         $property->setInheritable($inheritable);
  374.         $this->properties[$name] = $property;
  376.         return $this;
  377.     }
  379.     /**
  380.      * @internal
  381.      */
  382.     protected function updateModificationInfos()
  383.     {
  384.         if (Model\Version::isEnabled() === true) {
  385.             $this->setVersionCount($this->getDao()->getVersionCountForUpdate() + 1);
  386.         }
  388.         if ($this->getVersionCount() > 4200000000) {
  389.             $this->setVersionCount(1);
  390.         }
  392.         $modificationDateKey = 'modificationDate';
  393.         if (!$this->isFieldDirty($modificationDateKey)) {
  394.             $updateTime = time();
  395.             $this->setModificationDate($updateTime);
  396.         }
  398.         if (!$this->getCreationDate()) {
  399.             $this->setCreationDate($this->getModificationDate());
  400.         }
  402.         // auto assign user if possible, if not changed explicitly, if no user present, use ID=0 which represents the "system" user
  403.         $userModificationKey = 'userModification';
  404.         if (!$this->isFieldDirty($userModificationKey)) {
  405.             $userId = 0;
  406.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  407.             if ($user instanceof User) {
  408.                 $userId = $user->getId();
  409.             }
  410.             $this->setUserModification($userId);
  411.         }
  413.         if ($this->getUserOwner() === null) {
  414.             $this->setUserOwner($this->getUserModification());
  415.         }
  416.     }
  418.     /**
  419.      * {@inheritdoc}
  420.      */
  421.     public function getProperty($name, $asContainer = false)
  422.     {
  423.         $properties = $this->getProperties();
  424.         if ($this->hasProperty($name)) {
  425.             if ($asContainer) {
  426.                 return $properties[$name];
  427.             } else {
  428.                 return $properties[$name]->getData();
  429.             }
  430.         }
  432.         return null;
  433.     }
  435.     /**
  436.      * {@inheritdoc}
  437.      */
  438.     public function hasProperty($name)
  439.     {
  440.         $properties = $this->getProperties();
  442.         return array_key_exists($name, $properties);
  443.     }
  445.     /**
  446.      * @param string $name
  447.      */
  448.     public function removeProperty($name)
  449.     {
  450.         $properties = $this->getProperties();
  451.         unset($properties[$name]);
  452.         $this->setProperties($properties);
  453.     }
  455.     /**
  456.      * @return int
  457.      */
  458.     public function getVersionCount(): int
  459.     {
  460.         return $this->versionCount ? $this->versionCount : 0;
  461.     }
  463.     /**
  464.      * @param int|null $versionCount
  465.      *
  466.      * @return $this
  467.      */
  468.     public function setVersionCount(?int $versionCount): ElementInterface
  469.     {
  470.         $this->versionCount = (int) $versionCount;
  472.         return $this;
  473.     }
  475.     /**
  476.      * {@inheritdoc}
  477.      */
  478.     public function getCacheTag()
  479.     {
  480.         $elementType = Service::getElementType($this);
  482.         return Service::getElementCacheTag($elementType, $this->getId());
  483.     }
  485.     /**
  486.      * @internal
  487.      *
  488.      * @param string|int $id
  489.      *
  490.      * @return string
  491.      */
  492.     protected static function getCacheKey($id): string
  493.     {
  494.         $elementType = Service::getElementTypeByClassName(static::class);
  496.         return Service::getElementCacheTag($elementType, $id);
  497.     }
  499.     /**
  500.      * {@inheritdoc}
  501.      */
  502.     public function getCacheTags(array $tags = []): array
  503.     {
  504.         $tags[$this->getCacheTag()] = $this->getCacheTag();
  506.         return $tags;
  507.     }
  509.     /**
  510.      * Resolves the dependencies of the element and returns an array of them - Used by update()
  511.      *
  512.      * @internal
  513.      *
  514.      * @return array
  515.      */
  516.     protected function resolveDependencies(): array
  517.     {
  518.         $dependencies = [[]];
  520.         // check for properties
  521.         if (method_exists($this, 'getProperties')) {
  522.             foreach ($this->getProperties() as $property) {
  523.                 $dependencies[] = $property->resolveDependencies();
  524.             }
  525.         }
  527.         return array_merge(...$dependencies);
  528.     }
  530.     /**
  531.      * {@inheritdoc}
  532.      */
  533.     public function isLocked()
  534.     {
  535.         if ($this->getLocked()) {
  536.             return true;
  537.         }
  539.         // check for inherited
  540.         return $this->getDao()->isLocked();
  541.     }
  543.     /**
  544.      * @param User|null $user
  545.      *
  546.      * @return array
  547.      *
  548.      * @throws \Exception
  549.      *
  550.      * @internal
  551.      */
  552.     public function getUserPermissions(?User $user = null)
  553.     {
  554.         $baseClass = Service::getBaseClassNameForElement($this);
  555.         $workspaceClass = '\\Pimcore\\Model\\User\\Workspace\\' . $baseClass;
  556.         /** @var Model\AbstractModel $dummy */
  557.         $dummy = new $workspaceClass();
  558.         $vars = $dummy->getObjectVars();
  559.         $ignored = ['userId', 'cid', 'cpath', 'dao'];
  560.         $permissions = [];
  562.         $columns = array_diff(array_keys($vars), $ignored);
  563.         $defaultValue = 0;
  565.         if (null === $user) {
  566.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  567.         }
  569.         if ((!$user && php_sapi_name() === 'cli') || $user?->isAdmin()) {
  570.             $defaultValue = 1;
  571.         }
  573.         foreach ($columns as $name) {
  574.             $permissions[$name] = $defaultValue;
  575.         }
  577.         if (!$user || $user->isAdmin() || !$user->isAllowed(Service::getElementType($this) . 's')) {
  578.             return $permissions;
  579.         }
  581.         $permissions = $this->getDao()->areAllowed($columns, $user);
  583.         foreach ($permissions as $type => $isAllowed) {
  584.             $event = new ElementEvent($this, ['isAllowed' => $isAllowed, 'permissionType' => $type, 'user' => $user]);
  585.             \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::ELEMENT_PERMISSION_IS_ALLOWED);
  587.             $permissions[$type] = $event->getArgument('isAllowed');
  588.         }
  590.         return $permissions;
  591.     }
  593.     /**
  594.      * {@inheritdoc}
  595.      */
  596.     public function isAllowed($type, ?User $user = null)
  597.     {
  598.         if (null === $user) {
  599.             $user = \Pimcore\Tool\Admin::getCurrentUser();
  600.         }
  602.         if (!$user) {
  603.             if (php_sapi_name() === 'cli') {
  604.                 return true;
  605.             }
  607.             return false;
  608.         }
  610.         //everything is allowed for admin
  611.         if ($user->isAdmin()) {
  612.             return true;
  613.         }
  615.         if (!$user->isAllowed(Service::getElementType($this) . 's')) {
  616.             return false;
  617.         }
  618.         $isAllowed = $this->getDao()->isAllowed($type, $user);
  620.         $event = new ElementEvent($this, ['isAllowed' => $isAllowed, 'permissionType' => $type, 'user' => $user]);
  621.         \Pimcore::getEventDispatcher()->dispatch($event, AdminEvents::ELEMENT_PERMISSION_IS_ALLOWED);
  623.         return (bool) $event->getArgument('isAllowed');
  624.     }
  626.     /**
  627.      * @internal
  628.      */
  629.     public function unlockPropagate()
  630.     {
  631.         $type = Service::getElementType($this);
  633.         $ids = $this->getDao()->unlockPropagate();
  635.         // invalidate cache items
  636.         foreach ($ids as $id) {
  637.             $element = Service::getElementById($type, $id);
  638.             if ($element) {
  639.                 $element->clearDependentCache();
  640.             }
  641.         }
  642.     }
  644.     /**
  645.      * @internal
  646.      *
  647.      * @throws \Exception
  648.      */
  649.     protected function validatePathLength()
  650.     {
  651.         if (mb_strlen($this->getRealFullPath()) > 765) {
  652.             throw new \Exception("Full path is limited to 765 characters, reduce the length of your parent's path");
  653.         }
  654.     }
  656.     /**
  657.      * {@inheritdoc}
  658.      */
  659.     public function __toString()
  660.     {
  661.         return $this->getFullPath();
  662.     }
  664.     /**
  665.      * @return int
  666.      */
  667.     public function __getDataVersionTimestamp()
  668.     {
  669.         return $this->__dataVersionTimestamp;
  670.     }
  672.     /**
  673.      * @param int $_dataVersionTimestamp
  674.      */
  675.     public function __setDataVersionTimestamp($_dataVersionTimestamp)
  676.     {
  677.         $this->__dataVersionTimestamp = $_dataVersionTimestamp;
  678.     }
  680.     /**
  681.      * {@inheritdoc}
  682.      */
  683.     public function __isBasedOnLatestData()
  684.     {
  685.         return $this->getDao()->__isBasedOnLatestData();
  686.     }
  688.     /**
  689.      * @internal
  690.      *
  691.      * @param string|null $versionNote
  692.      * @param bool $saveOnlyVersion
  693.      * @param bool $saveStackTrace
  694.      * @param bool $isAutoSave
  695.      *
  696.      * @return Model\Version
  697.      *
  698.      * @throws \Exception
  699.      */
  700.     protected function doSaveVersion($versionNote = null, $saveOnlyVersion = true, $saveStackTrace = true, $isAutoSave = false)
  701.     {
  702.         $version = null;
  704.         if ($isAutoSave) {
  705.             $list = new Model\Version\Listing();
  706.             $list->setLoadAutoSave(true);
  707.             $list->setCondition('autoSave = 1 AND cid = ? AND cType = ? AND userId = ? ', [$this->getId(), Service::getElementType($this), $this->getUserModification()]);
  708.             $version = $list->current();
  709.         }
  711.         if (!$version) {
  712.             /** @var Model\Version $version */
  713.             $version = self::getModelFactory()->build(Model\Version::class);
  714.         }
  716.         $version->setCid($this->getId());
  717.         $version->setCtype(Service::getElementType($this));
  718.         $version->setDate($this->getModificationDate());
  719.         $version->setUserId($this->getUserModification());
  720.         $version->setData($this);
  721.         $version->setNote($versionNote);
  722.         $version->setGenerateStackTrace($saveStackTrace);
  723.         $version->setAutoSave($isAutoSave);
  725.         if ($saveOnlyVersion) {
  726.             $versionCount = $this->getDao()->getVersionCountForUpdate();
  727.             $versionCount++;
  728.         } else {
  729.             $versionCount = $this->getVersionCount();
  730.         }
  732.         $version->setVersionCount($versionCount);
  733.         $version->save();
  735.         return $version;
  736.     }
  738.     /**
  739.      * {@inheritdoc}
  740.      */
  741.     public function getDependencies()
  742.     {
  743.         if (!$this->dependencies) {
  744.             $this->dependencies = Model\Dependency::getBySourceId($this->getId(), Service::getElementType($this));
  745.         }
  747.         return $this->dependencies;
  748.     }
  750.     /**
  751.      * {@inheritdoc}
  752.      */
  753.     public function getScheduledTasks()
  754.     {
  755.         return [];
  756.     }
  758.     /**
  759.      * {@inheritdoc}
  760.      */
  761.     public function getVersions()
  762.     {
  763.         return [];
  764.     }
  766.     /**
  767.      * @internal
  768.      *
  769.      * @return string[]
  770.      */
  771.     protected function getBlockedVars(): array
  772.     {
  773.         return ['dependencies', 'parent'];
  774.     }
  776.     /**
  777.      * {@inheritdoc}
  778.      */
  779.     public function __sleep()
  780.     {
  781.         if ($this->isInDumpState()) {
  782.             // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  783.             $this->removeInheritedProperties();
  784.         }
  786.         return array_diff(parent::__sleep(), $this->getBlockedVars());
  787.     }
  789.     public function __wakeup()
  790.     {
  791.         if ($this->isInDumpState()) {
  792.             // 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 )
  793.             $originalElement = static::getById($this->getId());
  795.             if ($originalElement && !self::$doNotRestoreKeyAndPath) {
  796.                 // set key and path for DataObject and Document (assets have different wakeup call)
  797.                 $this->setKey($originalElement->getKey());
  798.                 $this->setPath($originalElement->getRealPath());
  799.             }
  800.         }
  802.         if ($this->isInDumpState() && $this->properties !== null) {
  803.             $this->renewInheritedProperties();
  804.         }
  806.         $this->setInDumpState(false);
  807.     }
  809.     public function __clone()
  810.     {
  811.         parent::__clone();
  812.         $this->dependencies = null;
  813.     }
  815.     /**
  816.      * @internal
  817.      *
  818.      * @param int $userId
  819.      */
  820.     public function deleteAutoSaveVersions($userId = null)
  821.     {
  822.         $list = new Model\Version\Listing();
  823.         $list->setLoadAutoSave(true);
  824.         if ($userId) {
  825.             $list->setCondition('`ctype` = ? AND cid = ? AND `autoSave` = 1 AND userId = ?', [Service::getElementType($this), $this->getId(), $userId]);
  826.         } else {
  827.             $list->setCondition('`ctype` = ? AND cid = ? AND `autoSave` = 1', [Service::getElementType($this), $this->getId()]);
  828.         }
  830.         foreach ($list->load() as $version) {
  831.             $version->delete();
  832.         }
  833.     }
  835.     /**
  836.      * @internal
  837.      */
  838.     protected function removeInheritedProperties()
  839.     {
  840.         $myProperties = $this->getProperties();
  842.         if ($myProperties) {
  843.             foreach ($this->getProperties() as $name => $property) {
  844.                 if ($property->getInherited()) {
  845.                     unset($myProperties[$name]);
  846.                 }
  847.             }
  848.         }
  850.         $this->setProperties($myProperties);
  851.     }
  853.     /**
  854.      * @internal
  855.      */
  856.     protected function renewInheritedProperties()
  857.     {
  858.         $this->removeInheritedProperties();
  860.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  861.         $cacheKey = self::getCacheKey($this->getId());
  862.         if (!RuntimeCache::isRegistered($cacheKey)) {
  863.             RuntimeCache::set($cacheKey, $this);
  864.         }
  866.         $myProperties = $this->getProperties();
  867.         $inheritedProperties = $this->getDao()->getProperties(true);
  868.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  869.     }
  870. }