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

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. }