vendor/pimcore/pimcore/models/Document.php line 266

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;
  18. use Doctrine\DBAL\Exception\DeadlockException;
  19. use Pimcore\Event\DocumentEvents;
  20. use Pimcore\Event\FrontendEvents;
  21. use Pimcore\Event\Model\DocumentEvent;
  22. use Pimcore\Logger;
  23. use Pimcore\Model\Document\Hardlink;
  24. use Pimcore\Model\Document\Hardlink\Wrapper\WrapperInterface;
  25. use Pimcore\Model\Document\Listing;
  26. use Pimcore\Model\Element\ElementInterface;
  27. use Pimcore\Model\Exception\NotFoundException;
  28. use Pimcore\Tool;
  29. use Pimcore\Tool\Frontend as FrontendTool;
  30. use Symfony\Cmf\Bundle\RoutingBundle\Routing\DynamicRouter;
  31. use Symfony\Component\EventDispatcher\GenericEvent;
  33. /**
  34. * @method \Pimcore\Model\Document\Dao getDao()
  35. * @method bool __isBasedOnLatestData()
  36. * @method int getChildAmount($user = null)
  37. * @method string getCurrentFullPath()
  38. */
  39. class Document extends Element\AbstractElement
  40. {
  41. /**
  42. * all possible types of documents
  43. *
  44. * @internal
  45. *
  46. * @deprecated will be removed in Pimcore 11. Use getTypes() method.
  47. *
  48. * @var array
  49. */
  50. public static $types = ['folder', 'page', 'snippet', 'link', 'hardlink', 'email', 'newsletter', 'printpage', 'printcontainer'];
  52. /**
  53. * @var bool
  54. */
  55. private static $hideUnpublished = false;
  57. /**
  58. * @internal
  59. *
  60. * @var string|null
  61. */
  62. protected $fullPathCache;
  64. /**
  65. * @internal
  66. *
  67. * @var int
  68. */
  69. protected $id;
  71. /**
  72. * @internal
  73. *
  74. * @var int
  75. */
  76. protected $parentId;
  78. /**
  79. * @internal
  80. *
  81. * @var self|null
  82. */
  83. protected $parent;
  85. /**
  86. * @internal
  87. *
  88. * @var string
  89. */
  90. protected string $type;
  92. /**
  93. * @internal
  94. *
  95. * @var string
  96. */
  97. protected $key;
  99. /**
  100. * @internal
  101. *
  102. * @var string
  103. */
  104. protected $path;
  106. /**
  107. * @internal
  108. *
  109. * @var int|null
  110. */
  111. protected ?int $index = null;
  113. /**
  114. * @internal
  115. *
  116. * @var bool
  117. */
  118. protected bool $published = true;
  120. /**
  121. * @internal
  122. *
  123. * @var int
  124. */
  125. protected $creationDate;
  127. /**
  128. * @internal
  129. *
  130. * @var int
  131. */
  132. protected $modificationDate;
  134. /**
  135. * @internal
  136. *
  137. * @var int|null
  138. */
  139. protected ?int $userOwner = null;
  141. /**
  142. * @internal
  143. *
  144. * @var int|null
  145. */
  146. protected ?int $userModification = null;
  148. /**
  149. * @internal
  150. *
  151. * @var array|null
  152. */
  153. protected $properties = null;
  155. /**
  156. * @internal
  157. *
  158. * @var array
  159. */
  160. protected $children = [];
  162. /**
  163. * @internal
  164. *
  165. * @var bool[]
  166. */
  167. protected $hasChildren = [];
  169. /**
  170. * @internal
  171. *
  172. * @var array
  173. */
  174. protected $siblings = [];
  176. /**
  177. * @internal
  178. *
  179. * @var bool[]
  180. */
  181. protected $hasSiblings = [];
  183. /**
  184. * enum('self','propagate') nullable
  185. *
  186. * @internal
  187. *
  188. * @var string|null
  189. */
  190. protected $locked = null;
  192. /**
  193. * @internal
  194. *
  195. * @var int
  196. */
  197. protected $versionCount;
  199. /**
  200. * get possible types
  201. *
  202. * @return array
  203. */
  204. public static function getTypes()
  205. {
  206. $documentsConfig = \Pimcore\Config::getSystemConfiguration('documents');
  208. return $documentsConfig['types'];
  209. }
  211. /**
  212. * @param string $path
  213. * @param bool $force
  214. *
  215. * @return static|null
  216. */
  217. public static function getByPath($path, $force = false)
  218. {
  219. $path = Element\Service::correctPath($path);
  221. $cacheKey = 'document_path_' . md5($path);
  223. if (\Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  224. return \Pimcore\Cache\Runtime::get($cacheKey);
  225. }
  227. $doc = null;
  229. try {
  230. $helperDoc = new Document();
  231. $helperDoc->getDao()->getByPath($path);
  232. $doc = static::getById($helperDoc->getId(), $force);
  233. \Pimcore\Cache\Runtime::set($cacheKey, $doc);
  234. } catch (NotFoundException $e) {
  235. $doc = null;
  236. }
  238. return $doc;
  239. }
  241. /**
  242. * @internal
  243. *
  244. * @param Document $document
  245. *
  246. * @return bool
  247. */
  248. protected static function typeMatch(Document $document)
  249. {
  250. $staticType = get_called_class();
  251. if ($staticType != Document::class) {
  252. if (!$document instanceof $staticType) {
  253. return false;
  254. }
  255. }
  257. return true;
  258. }
  260. /**
  261. * @param int $id
  262. * @param bool $force
  263. *
  264. * @return static|null
  265. */
  266. public static function getById($id, $force = false)
  267. {
  268. if (!is_numeric($id) || $id < 1) {
  269. return null;
  270. }
  272. $id = (int)$id;
  273. $cacheKey = self::getCacheKey($id);
  275. if (!$force && \Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  276. $document = \Pimcore\Cache\Runtime::get($cacheKey);
  277. if ($document && static::typeMatch($document)) {
  278. return $document;
  279. }
  280. }
  282. if ($force || !($document = \Pimcore\Cache::load($cacheKey))) {
  283. $document = new Document();
  285. try {
  286. $document->getDao()->getById($id);
  287. } catch (NotFoundException $e) {
  288. return null;
  289. }
  291. $className = 'Pimcore\\Model\\Document\\' . ucfirst($document->getType());
  293. // this is the fallback for custom document types using prefixes
  294. // so we need to check if the class exists first
  295. if (!Tool::classExists($className)) {
  296. $oldStyleClass = 'Document_' . ucfirst($document->getType());
  297. if (Tool::classExists($oldStyleClass)) {
  298. $className = $oldStyleClass;
  299. }
  300. }
  302. /** @var Document $document */
  303. $document = self::getModelFactory()->build($className);
  304. \Pimcore\Cache\Runtime::set($cacheKey, $document);
  306. $document->getDao()->getById($id);
  307. $document->__setDataVersionTimestamp($document->getModificationDate());
  309. $document->resetDirtyMap();
  311. \Pimcore\Cache::save($document, $cacheKey);
  312. } else {
  313. \Pimcore\Cache\Runtime::set($cacheKey, $document);
  314. }
  316. if (!$document || !static::typeMatch($document)) {
  317. return null;
  318. }
  320. return $document;
  321. }
  323. /**
  324. * @param int $parentId
  325. * @param array $data
  326. * @param bool $save
  327. *
  328. * @return static
  329. */
  330. public static function create($parentId, $data = [], $save = true)
  331. {
  332. $document = new static();
  333. $document->setParentId($parentId);
  334. self::checkCreateData($data);
  335. $document->setValues($data);
  337. if ($save) {
  338. $document->save();
  339. }
  341. return $document;
  342. }
  344. /**
  345. * @param array $config
  346. *
  347. * @return Listing
  348. *
  349. * @throws \Exception
  350. */
  351. public static function getList(array $config = []): Listing
  352. {
  353. /** @var Listing $list */
  354. $list = self::getModelFactory()->build(Listing::class);
  355. $list->setValues($config);
  357. return $list;
  358. }
  360. /**
  361. * @deprecated will be removed in Pimcore 11
  362. *
  363. * @param array $config
  364. *
  365. * @return int count
  366. */
  367. public static function getTotalCount(array $config = []): int
  368. {
  369. $list = static::getList($config);
  371. return $list->getTotalCount();
  372. }
  374. /**
  375. * {@inheritdoc}
  376. */
  377. public function save()
  378. {
  379. $isUpdate = false;
  381. try {
  382. // additional parameters (e.g. "versionNote" for the version note)
  383. $params = [];
  384. if (func_num_args() && is_array(func_get_arg(0))) {
  385. $params = func_get_arg(0);
  386. }
  388. $preEvent = new DocumentEvent($this, $params);
  389. if ($this->getId()) {
  390. $isUpdate = true;
  391. \Pimcore::getEventDispatcher()->dispatch($preEvent, DocumentEvents::PRE_UPDATE);
  392. } else {
  393. \Pimcore::getEventDispatcher()->dispatch($preEvent, DocumentEvents::PRE_ADD);
  394. }
  396. $params = $preEvent->getArguments();
  398. $this->correctPath();
  399. $differentOldPath = null;
  401. // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  402. // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  403. // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  404. $maxRetries = 5;
  405. for ($retries = 0; $retries < $maxRetries; $retries++) {
  406. $this->beginTransaction();
  408. try {
  409. $this->updateModificationInfos();
  411. if (!$isUpdate) {
  412. $this->getDao()->create();
  413. }
  415. // get the old path from the database before the update is done
  416. $oldPath = null;
  417. if ($isUpdate) {
  418. $oldPath = $this->getDao()->getCurrentFullPath();
  419. }
  421. $this->update($params);
  423. // if the old path is different from the new path, update all children
  424. $updatedChildren = [];
  425. if ($oldPath && $oldPath != $this->getRealFullPath()) {
  426. $differentOldPath = $oldPath;
  427. $this->getDao()->updateWorkspaces();
  428. $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  429. }
  431. $this->commit();
  433. break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  434. } catch (\Exception $e) {
  435. try {
  436. $this->rollBack();
  437. } catch (\Exception $er) {
  438. // PDO adapter throws exceptions if rollback fails
  439. Logger::error($er);
  440. }
  442. // we try to start the transaction $maxRetries times again (deadlocks, ...)
  443. if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  444. $run = $retries + 1;
  445. $waitTime = rand(1, 5) * 100000; // microseconds
  446. Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  448. usleep($waitTime); // wait specified time until we restart the transaction
  449. } else {
  450. // if the transaction still fail after $maxRetries retries, we throw out the exception
  451. throw $e;
  452. }
  453. }
  454. }
  456. $additionalTags = [];
  457. if (isset($updatedChildren) && is_array($updatedChildren)) {
  458. foreach ($updatedChildren as $documentId) {
  459. $tag = 'document_' . $documentId;
  460. $additionalTags[] = $tag;
  462. // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  463. \Pimcore\Cache\Runtime::set($tag, null);
  464. }
  465. }
  466. $this->clearDependentCache($additionalTags);
  468. $postEvent = new DocumentEvent($this, $params);
  469. if ($isUpdate) {
  470. if ($differentOldPath) {
  471. $postEvent->setArgument('oldPath', $differentOldPath);
  472. }
  473. \Pimcore::getEventDispatcher()->dispatch($postEvent, DocumentEvents::POST_UPDATE);
  474. } else {
  475. \Pimcore::getEventDispatcher()->dispatch($postEvent, DocumentEvents::POST_ADD);
  476. }
  478. return $this;
  479. } catch (\Exception $e) {
  480. $failureEvent = new DocumentEvent($this, $params);
  481. $failureEvent->setArgument('exception', $e);
  482. if ($isUpdate) {
  483. \Pimcore::getEventDispatcher()->dispatch($failureEvent, DocumentEvents::POST_UPDATE_FAILURE);
  484. } else {
  485. \Pimcore::getEventDispatcher()->dispatch($failureEvent, DocumentEvents::POST_ADD_FAILURE);
  486. }
  488. throw $e;
  489. }
  490. }
  492. /**
  493. * @throws \Exception
  494. */
  495. private function correctPath()
  496. {
  497. // set path
  498. if ($this->getId() != 1) { // not for the root node
  500. // check for a valid key, home has no key, so omit the check
  501. if (!Element\Service::isValidKey($this->getKey(), 'document')) {
  502. throw new \Exception('invalid key for document with id [ ' . $this->getId() . ' ] key is: [' . $this->getKey() . ']');
  503. }
  505. if ($this->getParentId() == $this->getId()) {
  506. throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  507. }
  509. $parent = Document::getById($this->getParentId());
  510. if ($parent) {
  511. // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  512. // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  513. $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  514. } else {
  515. // parent document doesn't exist anymore, set the parent to to root
  516. $this->setParentId(1);
  517. $this->setPath('/');
  518. }
  520. if (strlen($this->getKey()) < 1) {
  521. throw new \Exception('Document requires key, generated key automatically');
  522. }
  523. } elseif ($this->getId() == 1) {
  524. // some data in root node should always be the same
  525. $this->setParentId(0);
  526. $this->setPath('/');
  527. $this->setKey('');
  528. $this->setType('page');
  529. }
  531. if (Document\Service::pathExists($this->getRealFullPath())) {
  532. $duplicate = Document::getByPath($this->getRealFullPath());
  533. if ($duplicate instanceof Document && $duplicate->getId() != $this->getId()) {
  534. throw new \Exception('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save document');
  535. }
  536. }
  538. $this->validatePathLength();
  539. }
  541. /**
  542. * @internal
  543. *
  544. * @param array $params additional parameters (e.g. "versionNote" for the version note)
  545. *
  546. * @throws \Exception
  547. */
  548. protected function update($params = [])
  549. {
  550. $disallowedKeysInFirstLevel = ['install', 'admin', 'plugin'];
  551. if ($this->getParentId() == 1 && in_array($this->getKey(), $disallowedKeysInFirstLevel)) {
  552. throw new \Exception('Key: ' . $this->getKey() . ' is not allowed in first level (root-level)');
  553. }
  555. // set index if null
  556. if ($this->getIndex() === null) {
  557. $this->setIndex($this->getDao()->getNextIndex());
  558. }
  560. // save properties
  561. $this->getProperties();
  562. $this->getDao()->deleteAllProperties();
  563. if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  564. foreach ($this->getProperties() as $property) {
  565. if (!$property->getInherited()) {
  566. $property->setDao(null);
  567. $property->setCid($this->getId());
  568. $property->setCtype('document');
  569. $property->setCpath($this->getRealFullPath());
  570. $property->save();
  571. }
  572. }
  573. }
  575. // save dependencies
  576. $d = new Dependency();
  577. $d->setSourceType('document');
  578. $d->setSourceId($this->getId());
  580. foreach ($this->resolveDependencies() as $requirement) {
  581. if ($requirement['id'] == $this->getId() && $requirement['type'] == 'document') {
  582. // dont't add a reference to yourself
  583. continue;
  584. } else {
  585. $d->addRequirement($requirement['id'], $requirement['type']);
  586. }
  587. }
  588. $d->save();
  590. $this->getDao()->update();
  592. //set document to registry
  593. \Pimcore\Cache\Runtime::set(self::getCacheKey($this->getId()), $this);
  594. }
  596. /**
  597. * @internal
  598. *
  599. * @param int $index
  600. */
  601. public function saveIndex($index)
  602. {
  603. $this->getDao()->saveIndex($index);
  604. $this->clearDependentCache();
  605. }
  607. /**
  608. * {@inheritdoc}
  609. */
  610. public function clearDependentCache($additionalTags = [])
  611. {
  612. try {
  613. $tags = [$this->getCacheTag(), 'document_properties', 'output'];
  614. $tags = array_merge($tags, $additionalTags);
  616. \Pimcore\Cache::clearTags($tags);
  617. } catch (\Exception $e) {
  618. Logger::crit($e);
  619. }
  620. }
  622. /**
  623. * set the children of the document
  624. *
  625. * @param self[] $children
  626. * @param bool $includingUnpublished
  627. *
  628. * @return $this
  629. */
  630. public function setChildren($children, $includingUnpublished = false)
  631. {
  632. if (empty($children)) {
  633. // unset all cached children
  634. $this->hasChildren = [];
  635. $this->children = [];
  636. } elseif (is_array($children)) {
  637. $cacheKey = $this->getListingCacheKey([$includingUnpublished]);
  638. $this->children[$cacheKey] = $children;
  639. $this->hasChildren[$cacheKey] = (bool) count($children);
  640. }
  642. return $this;
  643. }
  645. /**
  646. * Get a list of the children (not recursivly)
  647. *
  648. * @param bool $includingUnpublished
  649. *
  650. * @return self[]
  651. */
  652. public function getChildren($includingUnpublished = false)
  653. {
  654. $cacheKey = $this->getListingCacheKey(func_get_args());
  656. if (!isset($this->children[$cacheKey])) {
  657. $list = new Document\Listing();
  658. $list->setUnpublished($includingUnpublished);
  659. $list->setCondition('parentId = ?', $this->getId());
  660. $list->setOrderKey('index');
  661. $list->setOrder('asc');
  662. $this->children[$cacheKey] = $list->load();
  663. }
  665. return $this->children[$cacheKey];
  666. }
  668. /**
  669. * Returns true if the document has at least one child
  670. *
  671. * @param bool $includingUnpublished
  672. *
  673. * @return bool
  674. */
  675. public function hasChildren($includingUnpublished = null)
  676. {
  677. $cacheKey = $this->getListingCacheKey(func_get_args());
  679. if (isset($this->hasChildren[$cacheKey])) {
  680. return $this->hasChildren[$cacheKey];
  681. }
  683. return $this->hasChildren[$cacheKey] = $this->getDao()->hasChildren($includingUnpublished);
  684. }
  686. /**
  687. * Get a list of the sibling documents
  688. *
  689. * @param bool $includingUnpublished
  690. *
  691. * @return array
  692. */
  693. public function getSiblings($includingUnpublished = false)
  694. {
  695. $cacheKey = $this->getListingCacheKey(func_get_args());
  697. if (!isset($this->siblings[$cacheKey])) {
  698. $list = new Document\Listing();
  699. $list->setUnpublished($includingUnpublished);
  700. // string conversion because parentId could be 0
  701. $list->addConditionParam('parentId = ?', (string)$this->getParentId());
  702. $list->addConditionParam('id != ?', $this->getId());
  703. $list->setOrderKey('index');
  704. $list->setOrder('asc');
  705. $this->siblings[$cacheKey] = $list->load();
  706. $this->hasSiblings[$cacheKey] = (bool) count($this->siblings[$cacheKey]);
  707. }
  709. return $this->siblings[$cacheKey];
  710. }
  712. /**
  713. * Returns true if the document has at least one sibling
  714. *
  715. * @param bool|null $includingUnpublished
  716. *
  717. * @return bool
  718. */
  719. public function hasSiblings($includingUnpublished = null)
  720. {
  721. $cacheKey = $this->getListingCacheKey(func_get_args());
  723. if (isset($this->hasSiblings[$cacheKey])) {
  724. return $this->hasSiblings[$cacheKey];
  725. }
  727. return $this->hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($includingUnpublished);
  728. }
  730. /**
  731. * {@inheritdoc}
  732. */
  733. public function getLocked()
  734. {
  735. if (empty($this->locked)) {
  736. return null;
  737. }
  739. return $this->locked;
  740. }
  742. /**
  743. * {@inheritdoc}
  744. */
  745. public function setLocked($locked)
  746. {
  747. $this->locked = $locked;
  749. return $this;
  750. }
  752. /**
  753. * @internal
  754. *
  755. * @throws \Exception
  756. */
  757. protected function doDelete()
  758. {
  759. // remove children
  760. if ($this->hasChildren()) {
  761. // delete also unpublished children
  762. $unpublishedStatus = self::doHideUnpublished();
  763. self::setHideUnpublished(false);
  764. foreach ($this->getChildren(true) as $child) {
  765. if (!$child instanceof WrapperInterface) {
  766. $child->delete();
  767. }
  768. }
  769. self::setHideUnpublished($unpublishedStatus);
  770. }
  772. // remove all properties
  773. $this->getDao()->deleteAllProperties();
  775. // remove permissions
  776. $this->getDao()->deleteAllPermissions();
  778. // remove dependencies
  779. $d = $this->getDependencies();
  780. $d->cleanAllForElement($this);
  782. // remove translations
  783. $service = new Document\Service;
  784. $service->removeTranslation($this);
  785. }
  787. /**
  788. * {@inheritdoc}
  789. */
  790. public function delete()
  791. {
  792. \Pimcore::getEventDispatcher()->dispatch(new DocumentEvent($this), DocumentEvents::PRE_DELETE);
  794. $this->beginTransaction();
  796. try {
  797. if ($this->getId() == 1) {
  798. throw new \Exception('root-node cannot be deleted');
  799. }
  801. $this->doDelete();
  802. $this->getDao()->delete();
  804. $this->commit();
  806. //clear parent data from registry
  807. $parentCacheKey = self::getCacheKey($this->getParentId());
  808. if (\Pimcore\Cache\Runtime::isRegistered($parentCacheKey)) {
  809. /** @var Document $parent */
  810. $parent = \Pimcore\Cache\Runtime::get($parentCacheKey);
  811. if ($parent instanceof self) {
  812. $parent->setChildren(null);
  813. }
  814. }
  815. } catch (\Exception $e) {
  816. $this->rollBack();
  817. $failureEvent = new DocumentEvent($this);
  818. $failureEvent->setArgument('exception', $e);
  819. \Pimcore::getEventDispatcher()->dispatch($failureEvent, DocumentEvents::POST_DELETE_FAILURE);
  820. Logger::error($e);
  822. throw $e;
  823. }
  825. // clear cache
  826. $this->clearDependentCache();
  828. //clear document from registry
  829. \Pimcore\Cache\Runtime::set(self::getCacheKey($this->getId()), null);
  831. \Pimcore::getEventDispatcher()->dispatch(new DocumentEvent($this), DocumentEvents::POST_DELETE);
  832. }
  834. /**
  835. * {@inheritdoc}
  836. */
  837. public function getFullPath(bool $force = false)
  838. {
  839. $link = $force ? null : $this->fullPathCache;
  841. // check if this document is also the site root, if so return /
  842. try {
  843. if (!$link && \Pimcore\Tool::isFrontend() && Site::isSiteRequest()) {
  844. $site = Site::getCurrentSite();
  845. if ($site instanceof Site) {
  846. if ($site->getRootDocument()->getId() == $this->getId()) {
  847. $link = '/';
  848. }
  849. }
  850. }
  851. } catch (\Exception $e) {
  852. Logger::error($e);
  853. }
  855. $requestStack = \Pimcore::getContainer()->get('request_stack');
  856. $masterRequest = $requestStack->getMasterRequest();
  858. // @TODO please forgive me, this is the dirtiest hack I've ever made :(
  859. // if you got confused by this functionality drop me a line and I'll buy you some beers :)
  861. // this is for the case that a link points to a document outside of the current site
  862. // in this case we look for a hardlink in the current site which points to the current document
  863. // why this could happen: we have 2 sites, in one site there's a hardlink to the other site and on a page inside
  864. // the hardlink there are snippets embedded and this snippets have links pointing to a document which is also
  865. // inside the hardlink scope, but this is an ID link, so we cannot rewrite the link the usual way because in the
  866. // snippet / link we don't know anymore that whe a inside a hardlink wrapped document
  867. if (!$link && \Pimcore\Tool::isFrontend() && Site::isSiteRequest() && !FrontendTool::isDocumentInCurrentSite($this)) {
  868. if ($masterRequest && ($masterDocument = $masterRequest->get(DynamicRouter::CONTENT_KEY))) {
  869. if ($masterDocument instanceof WrapperInterface) {
  870. $hardlinkPath = '';
  871. $hardlink = $masterDocument->getHardLinkSource();
  872. $hardlinkTarget = $hardlink->getSourceDocument();
  874. if ($hardlinkTarget) {
  875. $hardlinkPath = preg_replace('@^' . preg_quote(Site::getCurrentSite()->getRootPath(), '@') . '@', '', $hardlink->getRealFullPath());
  877. $link = preg_replace('@^' . preg_quote($hardlinkTarget->getRealFullPath(), '@') . '@',
  878. $hardlinkPath, $this->getRealFullPath());
  879. }
  881. if (strpos($this->getRealFullPath(), Site::getCurrentSite()->getRootDocument()->getRealFullPath()) === false && strpos($link, $hardlinkPath) === false) {
  882. $link = null;
  883. }
  884. }
  885. }
  887. if (!$link) {
  888. $config = \Pimcore\Config::getSystemConfiguration('general');
  889. $request = $requestStack->getCurrentRequest();
  890. $scheme = 'http://';
  891. if ($request) {
  892. $scheme = $request->getScheme() . '://';
  893. }
  895. /** @var Site $site */
  896. if ($site = FrontendTool::getSiteForDocument($this)) {
  897. if ($site->getMainDomain()) {
  898. // check if current document is the root of the different site, if so, preg_replace below doesn't work, so just return /
  899. if ($site->getRootDocument()->getId() == $this->getId()) {
  900. $link = $scheme . $site->getMainDomain() . '/';
  901. } else {
  902. $link = $scheme . $site->getMainDomain() .
  903. preg_replace('@^' . $site->getRootPath() . '/@', '/', $this->getRealFullPath());
  904. }
  905. }
  906. }
  908. if (!$link && !empty($config['domain']) && !($this instanceof WrapperInterface)) {
  909. $link = $scheme . $config['domain'] . $this->getRealFullPath();
  910. }
  911. }
  912. }
  914. if (!$link) {
  915. $link = $this->getPath() . $this->getKey();
  916. }
  918. if ($masterRequest) {
  919. // caching should only be done when master request is available as it is done for performance reasons
  920. // of the web frontend, without a request object there's no need to cache anything
  921. // for details also see https://github.com/pimcore/pimcore/issues/5707
  922. $this->fullPathCache = $link;
  923. }
  925. $link = $this->prepareFrontendPath($link);
  927. return $link;
  928. }
  930. /**
  931. * @param string $path
  932. *
  933. * @return string
  934. */
  935. private function prepareFrontendPath($path)
  936. {
  937. if (\Pimcore\Tool::isFrontend()) {
  938. $path = urlencode_ignore_slash($path);
  940. $event = new GenericEvent($this, [
  941. 'frontendPath' => $path,
  942. ]);
  943. \Pimcore::getEventDispatcher()->dispatch($event, FrontendEvents::DOCUMENT_PATH);
  944. $path = $event->getArgument('frontendPath');
  945. }
  947. return $path;
  948. }
  950. /**
  951. * {@inheritdoc}
  952. */
  953. public function getCreationDate()
  954. {
  955. return $this->creationDate;
  956. }
  958. /**
  959. * {@inheritdoc}
  960. */
  961. public function getId(): int
  962. {
  963. return (int) $this->id;
  964. }
  966. /**
  967. * {@inheritdoc}
  968. */
  969. public function getKey()
  970. {
  971. return $this->key;
  972. }
  974. /**
  975. * {@inheritdoc}
  976. */
  977. public function getModificationDate()
  978. {
  979. return $this->modificationDate;
  980. }
  982. /**
  983. * {@inheritdoc}
  984. */
  985. public function getParentId()
  986. {
  987. return $this->parentId;
  988. }
  990. /**
  991. * {@inheritdoc}
  992. */
  993. public function getPath()
  994. {
  995. // check for site, if so rewrite the path for output
  996. try {
  997. if (\Pimcore\Tool::isFrontend() && Site::isSiteRequest()) {
  998. $site = Site::getCurrentSite();
  999. if ($site instanceof Site) {
  1000. if ($site->getRootDocument() instanceof Document\Page && $site->getRootDocument() !== $this) {
  1001. $rootPath = $site->getRootPath();
  1002. $rootPath = preg_quote($rootPath, '@');
  1003. $link = preg_replace('@^' . $rootPath . '@', '', $this->path);
  1005. return $link;
  1006. }
  1007. }
  1008. }
  1009. } catch (\Exception $e) {
  1010. Logger::error($e);
  1011. }
  1013. return $this->path;
  1014. }
  1016. /**
  1017. * {@inheritdoc}
  1018. */
  1019. public function getRealPath()
  1020. {
  1021. return $this->path;
  1022. }
  1024. /**
  1025. * {@inheritdoc}
  1026. */
  1027. public function getRealFullPath()
  1028. {
  1029. $path = $this->getRealPath() . $this->getKey();
  1031. return $path;
  1032. }
  1034. /**
  1035. * {@inheritdoc}
  1036. */
  1037. public function setCreationDate($creationDate)
  1038. {
  1039. $this->creationDate = (int) $creationDate;
  1041. return $this;
  1042. }
  1044. /**
  1045. * {@inheritdoc}
  1046. */
  1047. public function setId($id)
  1048. {
  1049. $this->id = (int) $id;
  1051. return $this;
  1052. }
  1054. /**
  1055. * {@inheritdoc}
  1056. */
  1057. public function setKey($key)
  1058. {
  1059. $this->key = $key;
  1061. return $this;
  1062. }
  1064. /**
  1065. * {@inheritdoc}
  1066. */
  1067. public function setModificationDate($modificationDate)
  1068. {
  1069. $this->markFieldDirty('modificationDate');
  1071. $this->modificationDate = (int) $modificationDate;
  1073. return $this;
  1074. }
  1076. /**
  1077. * Set the parent id of the document.
  1078. *
  1079. * @param int $parentId
  1080. *
  1081. * @return Document
  1082. */
  1083. public function setParentId($parentId)
  1084. {
  1085. $this->parentId = (int) $parentId;
  1086. $this->parent = null;
  1087. $this->siblings = [];
  1088. $this->hasSiblings = [];
  1090. return $this;
  1091. }
  1093. /**
  1094. * {@inheritdoc}
  1095. */
  1096. public function setPath($path)
  1097. {
  1098. $this->path = $path;
  1100. return $this;
  1101. }
  1103. /**
  1104. * Returns the document index.
  1105. *
  1106. * @return int|null
  1107. */
  1108. public function getIndex(): ?int
  1109. {
  1110. return $this->index;
  1111. }
  1113. /**
  1114. * Set the document index.
  1115. *
  1116. * @param int $index
  1117. *
  1118. * @return Document
  1119. */
  1120. public function setIndex($index)
  1121. {
  1122. $this->index = (int) $index;
  1124. return $this;
  1125. }
  1127. /**
  1128. * {@inheritdoc}
  1129. */
  1130. public function getType()
  1131. {
  1132. return $this->type;
  1133. }
  1135. /**
  1136. * Set the document type.
  1137. *
  1138. * @param string $type
  1139. *
  1140. * @return Document
  1141. */
  1142. public function setType($type)
  1143. {
  1144. $this->type = $type;
  1146. return $this;
  1147. }
  1149. /**
  1150. * {@inheritdoc}
  1151. */
  1152. public function getUserModification()
  1153. {
  1154. return $this->userModification;
  1155. }
  1157. /**
  1158. * {@inheritdoc}
  1159. */
  1160. public function getUserOwner()
  1161. {
  1162. return $this->userOwner;
  1163. }
  1165. /**
  1166. * {@inheritdoc}
  1167. */
  1168. public function setUserModification($userModification)
  1169. {
  1170. $this->markFieldDirty('userModification');
  1172. $this->userModification = (int) $userModification;
  1174. return $this;
  1175. }
  1177. /**
  1178. * {@inheritdoc}
  1179. */
  1180. public function setUserOwner($userOwner)
  1181. {
  1182. $this->userOwner = (int) $userOwner;
  1184. return $this;
  1185. }
  1187. /**
  1188. * @return bool
  1189. */
  1190. public function isPublished()
  1191. {
  1192. return $this->getPublished();
  1193. }
  1195. /**
  1196. * @return bool
  1197. */
  1198. public function getPublished()
  1199. {
  1200. return (bool) $this->published;
  1201. }
  1203. /**
  1204. * @param bool $published
  1205. *
  1206. * @return Document
  1207. */
  1208. public function setPublished($published)
  1209. {
  1210. $this->published = (bool) $published;
  1212. return $this;
  1213. }
  1215. /**
  1216. * {@inheritdoc}
  1217. */
  1218. public function getProperties()
  1219. {
  1220. if ($this->properties === null) {
  1221. // try to get from cache
  1222. $cacheKey = 'document_properties_' . $this->getId();
  1223. $properties = \Pimcore\Cache::load($cacheKey);
  1224. if (!is_array($properties)) {
  1225. $properties = $this->getDao()->getProperties();
  1226. $elementCacheTag = $this->getCacheTag();
  1227. $cacheTags = ['document_properties' => 'document_properties', $elementCacheTag => $elementCacheTag];
  1228. \Pimcore\Cache::save($properties, $cacheKey, $cacheTags);
  1229. }
  1231. $this->setProperties($properties);
  1232. }
  1234. return $this->properties;
  1235. }
  1237. /**
  1238. * {@inheritdoc}
  1239. */
  1240. public function setProperties(?array $properties)
  1241. {
  1242. $this->properties = $properties;
  1244. return $this;
  1245. }
  1247. /**
  1248. * {@inheritdoc}
  1249. */
  1250. public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1251. {
  1252. $this->getProperties();
  1254. $property = new Property();
  1255. $property->setType($type);
  1256. $property->setCid($this->getId());
  1257. $property->setName($name);
  1258. $property->setCtype('document');
  1259. $property->setData($data);
  1260. $property->setInherited($inherited);
  1261. $property->setInheritable($inheritable);
  1263. $this->properties[$name] = $property;
  1265. return $this;
  1266. }
  1268. /**
  1269. * {@inheritdoc}
  1270. */
  1271. public function getParent()
  1272. {
  1273. if ($this->parent === null) {
  1274. $this->setParent(Document::getById($this->getParentId()));
  1275. }
  1277. return $this->parent;
  1278. }
  1280. /**
  1281. * Set the parent document instance.
  1282. *
  1283. * @param Document $parent
  1284. *
  1285. * @return Document
  1286. */
  1287. public function setParent($parent)
  1288. {
  1289. $this->parent = $parent;
  1290. if ($parent instanceof Document) {
  1291. $this->parentId = $parent->getId();
  1292. }
  1294. return $this;
  1295. }
  1297. public function __sleep()
  1298. {
  1299. $parentVars = parent::__sleep();
  1300. $blockedVars = ['hasChildren', 'versions', 'scheduledTasks', 'parent', 'fullPathCache'];
  1302. if ($this->isInDumpState()) {
  1303. // this is if we want to make a full dump of the object (eg. for a new version), including children for recyclebin
  1304. $this->removeInheritedProperties();
  1305. } else {
  1306. // this is if we want to cache the object
  1307. $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  1308. }
  1310. return array_diff($parentVars, $blockedVars);
  1311. }
  1313. public function __wakeup()
  1314. {
  1315. if ($this->isInDumpState()) {
  1316. // 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)
  1317. $originalElement = Document::getById($this->getId());
  1318. if ($originalElement) {
  1319. $this->setKey($originalElement->getKey());
  1320. $this->setPath($originalElement->getRealPath());
  1321. }
  1322. }
  1324. if ($this->isInDumpState() && $this->properties !== null) {
  1325. $this->renewInheritedProperties();
  1326. }
  1328. $this->setInDumpState(false);
  1329. }
  1331. /**
  1332. * Set true if want to hide documents.
  1333. *
  1334. * @param bool $hideUnpublished
  1335. */
  1336. public static function setHideUnpublished($hideUnpublished)
  1337. {
  1338. self::$hideUnpublished = $hideUnpublished;
  1339. }
  1341. /**
  1342. * Checks if unpublished documents should be hidden.
  1343. *
  1344. * @return bool
  1345. */
  1346. public static function doHideUnpublished()
  1347. {
  1348. return self::$hideUnpublished;
  1349. }
  1351. /**
  1352. * {@inheritdoc}
  1353. */
  1354. public function getVersionCount(): int
  1355. {
  1356. return $this->versionCount ? $this->versionCount : 0;
  1357. }
  1359. /**
  1360. * {@inheritdoc}
  1361. */
  1362. public function setVersionCount(?int $versionCount): ElementInterface
  1363. {
  1364. $this->versionCount = (int) $versionCount;
  1366. return $this;
  1367. }
  1369. /**
  1370. * @internal
  1371. *
  1372. * @param array $args
  1373. *
  1374. * @return string
  1375. */
  1376. protected function getListingCacheKey(array $args = [])
  1377. {
  1378. $unpublished = (bool)($args[0] ?? false);
  1379. $cacheKey = (string)$unpublished;
  1381. return $cacheKey;
  1382. }
  1384. public function __clone()
  1385. {
  1386. parent::__clone();
  1387. $this->parent = null;
  1388. $this->hasSiblings = [];
  1389. $this->siblings = [];
  1390. $this->fullPathCache = null;
  1391. }
  1392. }