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

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\Cache\RuntimeCache;
  20. use Pimcore\Event\DocumentEvents;
  21. use Pimcore\Event\FrontendEvents;
  22. use Pimcore\Event\Model\DocumentEvent;
  23. use Pimcore\Logger;
  24. use Pimcore\Model\Document\Hardlink\Wrapper\WrapperInterface;
  25. use Pimcore\Model\Document\Listing;
  26. use Pimcore\Model\Element\DuplicateFullPathException;
  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 string
  68. */
  69. protected string $type = '';
  71. /**
  72. * @internal
  73. *
  74. * @var string|null
  75. */
  76. protected $key;
  78. /**
  79. * @internal
  80. *
  81. * @var string|null
  82. */
  83. protected $path;
  85. /**
  86. * @internal
  87. *
  88. * @var int|null
  89. */
  90. protected ?int $index = null;
  92. /**
  93. * @internal
  94. *
  95. * @var bool
  96. */
  97. protected bool $published = true;
  99. /**
  100. * @internal
  101. *
  102. * @var int|null
  103. */
  104. protected ?int $userModification = null;
  106. /**
  107. * @internal
  108. *
  109. * @var array
  110. */
  111. protected $children = [];
  113. /**
  114. * @internal
  115. *
  116. * @var bool[]
  117. */
  118. protected $hasChildren = [];
  120. /**
  121. * @internal
  122. *
  123. * @var array
  124. */
  125. protected $siblings = [];
  127. /**
  128. * @internal
  129. *
  130. * @var bool[]
  131. */
  132. protected $hasSiblings = [];
  134. /**
  135. * {@inheritdoc}
  136. */
  137. protected function getBlockedVars(): array
  138. {
  139. $blockedVars = ['hasChildren', 'versions', 'scheduledTasks', 'parent', 'fullPathCache'];
  141. if (!$this->isInDumpState()) {
  142. // this is if we want to cache the object
  143. $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  144. }
  146. return $blockedVars;
  147. }
  149. /**
  150. * get possible types
  151. *
  152. * @return array
  153. */
  154. public static function getTypes()
  155. {
  156. $documentsConfig = \Pimcore\Config::getSystemConfiguration('documents');
  158. return $documentsConfig['types'];
  159. }
  161. /**
  162. * @internal
  163. *
  164. * @param string $path
  165. *
  166. * @return string
  167. */
  168. protected static function getPathCacheKey(string $path): string
  169. {
  170. return 'document_path_' . md5($path);
  171. }
  173. /**
  174. * @param string $path
  175. * @param array|bool $force
  176. *
  177. * @return static|null
  178. */
  179. public static function getByPath($path, $force = false)
  180. {
  181. if (!$path) {
  182. return null;
  183. }
  185. $path = Element\Service::correctPath($path);
  187. $cacheKey = self::getPathCacheKey($path);
  188. $params = Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  190. if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  191. $document = RuntimeCache::get($cacheKey);
  192. if ($document && static::typeMatch($document)) {
  193. return $document;
  194. }
  195. }
  197. try {
  198. $helperDoc = new Document();
  199. $helperDoc->getDao()->getByPath($path);
  200. $doc = static::getById($helperDoc->getId(), $params);
  201. RuntimeCache::set($cacheKey, $doc);
  202. } catch (NotFoundException $e) {
  203. $doc = null;
  204. }
  206. return $doc;
  207. }
  209. /**
  210. * @internal
  211. *
  212. * @param Document $document
  213. *
  214. * @return bool
  215. */
  216. protected static function typeMatch(Document $document)
  217. {
  218. $staticType = static::class;
  219. if ($staticType !== Document::class) {
  220. if (!$document instanceof $staticType) {
  221. return false;
  222. }
  223. }
  225. return true;
  226. }
  228. /**
  229. * @param int $id
  230. * @param array|bool $force
  231. *
  232. * @return static|null
  233. */
  234. public static function getById($id, $force = false)
  235. {
  236. if (!is_numeric($id) || $id < 1) {
  237. return null;
  238. }
  240. $id = (int)$id;
  241. $cacheKey = self::getCacheKey($id);
  242. $params = Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  244. if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  245. $document = RuntimeCache::get($cacheKey);
  246. if ($document && static::typeMatch($document)) {
  247. return $document;
  248. }
  249. }
  251. if ($params['force'] || !($document = \Pimcore\Cache::load($cacheKey))) {
  252. $reflectionClass = new \ReflectionClass(static::class);
  253. if ($reflectionClass->isAbstract()) {
  254. $document = new Document();
  255. } else {
  256. $document = new static();
  257. }
  259. try {
  260. $document->getDao()->getById($id);
  261. } catch (NotFoundException $e) {
  262. return null;
  263. }
  265. $className = 'Pimcore\\Model\\Document\\' . ucfirst($document->getType());
  267. // this is the fallback for custom document types using prefixes
  268. // so we need to check if the class exists first
  269. if (!Tool::classExists($className)) {
  270. $oldStyleClass = 'Document_' . ucfirst($document->getType());
  271. if (Tool::classExists($oldStyleClass)) {
  272. $className = $oldStyleClass;
  273. }
  274. }
  275. /** @var Document $newDocument */
  276. $newDocument = self::getModelFactory()->build($className);
  278. if (get_class($document) !== get_class($newDocument)) {
  279. $document = $newDocument;
  280. $document->getDao()->getById($id);
  281. }
  283. RuntimeCache::set($cacheKey, $document);
  284. $document->__setDataVersionTimestamp($document->getModificationDate());
  286. $document->resetDirtyMap();
  288. \Pimcore\Cache::save($document, $cacheKey);
  289. } else {
  290. RuntimeCache::set($cacheKey, $document);
  291. }
  293. if (!$document || !static::typeMatch($document)) {
  294. return null;
  295. }
  297. \Pimcore::getEventDispatcher()->dispatch(
  298. new DocumentEvent($document, ['params' => $params]),
  299. DocumentEvents::POST_LOAD
  300. );
  302. return $document;
  303. }
  305. /**
  306. * @param int $parentId
  307. * @param array $data
  308. * @param bool $save
  309. *
  310. * @return static
  311. */
  312. public static function create($parentId, $data = [], $save = true)
  313. {
  314. $document = new static();
  315. $document->setParentId($parentId);
  316. self::checkCreateData($data);
  317. $document->setValues($data);
  319. if ($save) {
  320. $document->save();
  321. }
  323. return $document;
  324. }
  326. /**
  327. * @param array $config
  328. *
  329. * @return Listing
  330. *
  331. * @throws \Exception
  332. */
  333. public static function getList(array $config = []): Listing
  334. {
  335. /** @var Listing $list */
  336. $list = self::getModelFactory()->build(Listing::class);
  337. $list->setValues($config);
  339. return $list;
  340. }
  342. /**
  343. * @deprecated will be removed in Pimcore 11
  344. *
  345. * @param array $config
  346. *
  347. * @return int count
  348. */
  349. public static function getTotalCount(array $config = []): int
  350. {
  351. $list = static::getList($config);
  353. return $list->getTotalCount();
  354. }
  356. /**
  357. * {@inheritdoc}
  358. */
  359. public function save()
  360. {
  361. $isUpdate = false;
  363. try {
  364. // additional parameters (e.g. "versionNote" for the version note)
  365. $params = [];
  366. if (func_num_args() && is_array(func_get_arg(0))) {
  367. $params = func_get_arg(0);
  368. }
  370. $preEvent = new DocumentEvent($this, $params);
  371. if ($this->getId()) {
  372. $isUpdate = true;
  373. $this->dispatchEvent($preEvent, DocumentEvents::PRE_UPDATE);
  374. } else {
  375. $this->dispatchEvent($preEvent, DocumentEvents::PRE_ADD);
  376. }
  378. $params = $preEvent->getArguments();
  380. $this->correctPath();
  381. $differentOldPath = null;
  383. // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  384. // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  385. // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  386. $maxRetries = 5;
  387. for ($retries = 0; $retries < $maxRetries; $retries++) {
  388. $this->beginTransaction();
  390. try {
  391. $this->updateModificationInfos();
  393. if (!$isUpdate) {
  394. $this->getDao()->create();
  395. }
  397. // get the old path from the database before the update is done
  398. $oldPath = null;
  399. if ($isUpdate) {
  400. $oldPath = $this->getDao()->getCurrentFullPath();
  401. }
  403. $this->update($params);
  405. // if the old path is different from the new path, update all children
  406. $updatedChildren = [];
  407. if ($oldPath && $oldPath !== $newPath = $this->getRealFullPath()) {
  408. $differentOldPath = $oldPath;
  409. $this->getDao()->updateWorkspaces();
  410. $updatedChildren = array_map(
  411. static function (array $doc) use ($oldPath, $newPath): array {
  412. $doc['oldPath'] = substr_replace($doc['path'], $oldPath, 0, strlen($newPath));
  414. return $doc;
  415. },
  416. $this->getDao()->updateChildPaths($oldPath),
  417. );
  418. }
  420. $this->commit();
  422. break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  423. } catch (\Exception $e) {
  424. try {
  425. $this->rollBack();
  426. } catch (\Exception $er) {
  427. // PDO adapter throws exceptions if rollback fails
  428. Logger::error((string) $er);
  429. }
  431. // we try to start the transaction $maxRetries times again (deadlocks, ...)
  432. if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  433. $run = $retries + 1;
  434. $waitTime = rand(1, 5) * 100000; // microseconds
  435. Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  437. usleep($waitTime); // wait specified time until we restart the transaction
  438. } else {
  439. // if the transaction still fail after $maxRetries retries, we throw out the exception
  440. throw $e;
  441. }
  442. }
  443. }
  445. $additionalTags = [];
  446. if (isset($updatedChildren) && is_array($updatedChildren)) {
  447. foreach ($updatedChildren as $updatedDocument) {
  448. $tag = self::getCacheKey($updatedDocument['id']);
  449. $additionalTags[] = $tag;
  451. // remove the child also from registry (internal cache) to avoid path inconsistencies during long-running scripts, such as CLI
  452. RuntimeCache::set($tag, null);
  453. RuntimeCache::set(self::getPathCacheKey($updatedDocument['oldPath']), null);
  454. }
  455. }
  456. $this->clearDependentCache($additionalTags);
  458. $postEvent = new DocumentEvent($this, $params);
  459. if ($isUpdate) {
  460. if ($differentOldPath) {
  461. $postEvent->setArgument('oldPath', $differentOldPath);
  462. }
  463. $this->dispatchEvent($postEvent, DocumentEvents::POST_UPDATE);
  464. } else {
  465. $this->dispatchEvent($postEvent, DocumentEvents::POST_ADD);
  466. }
  468. return $this;
  469. } catch (\Exception $e) {
  470. $failureEvent = new DocumentEvent($this, $params);
  471. $failureEvent->setArgument('exception', $e);
  472. if ($isUpdate) {
  473. $this->dispatchEvent($failureEvent, DocumentEvents::POST_UPDATE_FAILURE);
  474. } else {
  475. $this->dispatchEvent($failureEvent, DocumentEvents::POST_ADD_FAILURE);
  476. }
  478. throw $e;
  479. }
  480. }
  482. /**
  483. * @throws \Exception|DuplicateFullPathException
  484. */
  485. private function correctPath()
  486. {
  487. // set path
  488. if ($this->getId() != 1) { // not for the root node
  489. // check for a valid key, home has no key, so omit the check
  490. if (!Element\Service::isValidKey($this->getKey(), 'document')) {
  491. throw new \Exception('invalid key for document with id [ ' . $this->getId() . ' ] key is: [' . $this->getKey() . ']');
  492. }
  494. if ($this->getParentId() == $this->getId()) {
  495. throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  496. }
  498. $parent = Document::getById($this->getParentId());
  499. if ($parent) {
  500. // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  501. // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  502. $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  503. } else {
  504. trigger_deprecation(
  505. 'pimcore/pimcore',
  506. '10.5',
  507. 'Fallback for parentId will be removed in Pimcore 11.',
  508. );
  509. // parent document doesn't exist anymore, set the parent to to root
  510. $this->setParentId(1);
  511. $this->setPath('/');
  512. }
  514. if (strlen($this->getKey()) < 1) {
  515. throw new \Exception('Document requires key, generated key automatically');
  516. }
  517. } elseif ($this->getId() == 1) {
  518. // some data in root node should always be the same
  519. $this->setParentId(0);
  520. $this->setPath('/');
  521. $this->setKey('');
  522. $this->setType('page');
  523. }
  525. if (Document\Service::pathExists($this->getRealFullPath())) {
  526. $duplicate = Document::getByPath($this->getRealFullPath());
  527. if ($duplicate instanceof Document && $duplicate->getId() != $this->getId()) {
  528. $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save document');
  529. $duplicateFullPathException->setDuplicateElement($duplicate);
  531. throw $duplicateFullPathException;
  532. }
  533. }
  535. $this->validatePathLength();
  536. }
  538. /**
  539. * @internal
  540. *
  541. * @param array $params additional parameters (e.g. "versionNote" for the version note)
  542. *
  543. * @throws \Exception
  544. */
  545. protected function update($params = [])
  546. {
  547. $disallowedKeysInFirstLevel = ['install', 'admin', 'plugin'];
  548. if ($this->getParentId() == 1 && in_array($this->getKey(), $disallowedKeysInFirstLevel)) {
  549. throw new \Exception('Key: ' . $this->getKey() . ' is not allowed in first level (root-level)');
  550. }
  552. // set index if null
  553. if ($this->getIndex() === null) {
  554. $this->setIndex($this->getDao()->getNextIndex());
  555. }
  557. // save properties
  558. $this->getProperties();
  559. $this->getDao()->deleteAllProperties();
  560. if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  561. foreach ($this->getProperties() as $property) {
  562. if (!$property->getInherited()) {
  563. $property->setDao(null);
  564. $property->setCid($this->getId());
  565. $property->setCtype('document');
  566. $property->setCpath($this->getRealFullPath());
  567. $property->save();
  568. }
  569. }
  570. }
  572. // save dependencies
  573. $d = new Dependency();
  574. $d->setSourceType('document');
  575. $d->setSourceId($this->getId());
  577. foreach ($this->resolveDependencies() as $requirement) {
  578. if ($requirement['id'] == $this->getId() && $requirement['type'] == 'document') {
  579. // dont't add a reference to yourself
  580. continue;
  581. } else {
  582. $d->addRequirement($requirement['id'], $requirement['type']);
  583. }
  584. }
  585. $d->save();
  587. $this->getDao()->update();
  589. //set document to registry
  590. RuntimeCache::set(self::getCacheKey($this->getId()), $this);
  591. }
  593. /**
  594. * @internal
  595. *
  596. * @param int $index
  597. */
  598. public function saveIndex($index)
  599. {
  600. $this->getDao()->saveIndex($index);
  601. $this->clearDependentCache();
  602. }
  604. /**
  605. * {@inheritdoc}
  606. */
  607. public function clearDependentCache($additionalTags = [])
  608. {
  609. try {
  610. $tags = [$this->getCacheTag(), 'document_properties', 'output'];
  611. $tags = array_merge($tags, $additionalTags);
  613. \Pimcore\Cache::clearTags($tags);
  614. } catch (\Exception $e) {
  615. Logger::crit((string) $e);
  616. }
  617. }
  619. /**
  620. * set the children of the document
  621. *
  622. * @param Document[]|null $children
  623. * @param bool $includingUnpublished
  624. *
  625. * @return $this
  626. */
  627. public function setChildren($children, $includingUnpublished = false)
  628. {
  629. if ($children === null) {
  630. // unset all cached children
  631. $this->hasChildren = [];
  632. $this->children = [];
  633. } elseif (is_array($children)) {
  634. $cacheKey = $this->getListingCacheKey([$includingUnpublished]);
  635. $this->children[$cacheKey] = $children;
  636. $this->hasChildren[$cacheKey] = (bool) count($children);
  637. }
  639. return $this;
  640. }
  642. /**
  643. * Get a list of the children (not recursivly)
  644. *
  645. * @param bool $includingUnpublished
  646. *
  647. * @return self[]
  648. */
  649. public function getChildren($includingUnpublished = false)
  650. {
  651. $cacheKey = $this->getListingCacheKey(func_get_args());
  653. if (!isset($this->children[$cacheKey])) {
  654. if ($this->getId()) {
  655. $list = new Document\Listing();
  656. $list->setUnpublished($includingUnpublished);
  657. $list->setCondition('parentId = ?', $this->getId());
  658. $list->setOrderKey('index');
  659. $list->setOrder('asc');
  660. $this->children[$cacheKey] = $list->load();
  661. } else {
  662. $this->children[$cacheKey] = [];
  663. }
  664. }
  666. return $this->children[$cacheKey];
  667. }
  669. /**
  670. * Returns true if the document has at least one child
  671. *
  672. * @param bool $includingUnpublished
  673. *
  674. * @return bool
  675. */
  676. public function hasChildren($includingUnpublished = null)
  677. {
  678. $cacheKey = $this->getListingCacheKey(func_get_args());
  680. if (isset($this->hasChildren[$cacheKey])) {
  681. return $this->hasChildren[$cacheKey];
  682. }
  684. return $this->hasChildren[$cacheKey] = $this->getDao()->hasChildren($includingUnpublished);
  685. }
  687. /**
  688. * Get a list of the sibling documents
  689. *
  690. * @param bool $includingUnpublished
  691. *
  692. * @return array
  693. */
  694. public function getSiblings($includingUnpublished = false)
  695. {
  696. $cacheKey = $this->getListingCacheKey(func_get_args());
  698. if (!isset($this->siblings[$cacheKey])) {
  699. if ($this->getParentId()) {
  700. $list = new Document\Listing();
  701. $list->setUnpublished($includingUnpublished);
  702. $list->addConditionParam('parentId = ?', $this->getParentId());
  703. if ($this->getId()) {
  704. $list->addConditionParam('id != ?', $this->getId());
  705. }
  706. $list->setOrderKey('index');
  707. $list->setOrder('asc');
  708. $this->siblings[$cacheKey] = $list->load();
  709. $this->hasSiblings[$cacheKey] = (bool) count($this->siblings[$cacheKey]);
  710. } else {
  711. $this->siblings[$cacheKey] = [];
  712. $this->hasSiblings[$cacheKey] = false;
  713. }
  714. }
  716. return $this->siblings[$cacheKey];
  717. }
  719. /**
  720. * Returns true if the document has at least one sibling
  721. *
  722. * @param bool|null $includingUnpublished
  723. *
  724. * @return bool
  725. */
  726. public function hasSiblings($includingUnpublished = null)
  727. {
  728. $cacheKey = $this->getListingCacheKey(func_get_args());
  730. if (isset($this->hasSiblings[$cacheKey])) {
  731. return $this->hasSiblings[$cacheKey];
  732. }
  734. return $this->hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($includingUnpublished);
  735. }
  737. /**
  738. * @internal
  739. *
  740. * @throws \Exception
  741. */
  742. protected function doDelete()
  743. {
  744. // remove children
  745. if ($this->hasChildren()) {
  746. // delete also unpublished children
  747. $unpublishedStatus = self::doHideUnpublished();
  748. self::setHideUnpublished(false);
  749. foreach ($this->getChildren(true) as $child) {
  750. if (!$child instanceof WrapperInterface) {
  751. $child->delete();
  752. }
  753. }
  754. self::setHideUnpublished($unpublishedStatus);
  755. }
  757. // remove all properties
  758. $this->getDao()->deleteAllProperties();
  760. // remove dependencies
  761. $d = $this->getDependencies();
  762. $d->cleanAllForElement($this);
  764. // remove translations
  765. $service = new Document\Service;
  766. $service->removeTranslation($this);
  767. }
  769. /**
  770. * {@inheritdoc}
  771. */
  772. public function delete()
  773. {
  774. $this->dispatchEvent(new DocumentEvent($this), DocumentEvents::PRE_DELETE);
  776. $this->beginTransaction();
  778. try {
  779. if ($this->getId() == 1) {
  780. throw new \Exception('root-node cannot be deleted');
  781. }
  783. $this->doDelete();
  784. $this->getDao()->delete();
  786. $this->commit();
  788. //clear parent data from registry
  789. $parentCacheKey = self::getCacheKey($this->getParentId());
  790. if (RuntimeCache::isRegistered($parentCacheKey)) {
  791. /** @var Document $parent */
  792. $parent = RuntimeCache::get($parentCacheKey);
  793. if ($parent instanceof self) {
  794. $parent->setChildren(null);
  795. }
  796. }
  797. } catch (\Exception $e) {
  798. $this->rollBack();
  799. $failureEvent = new DocumentEvent($this);
  800. $failureEvent->setArgument('exception', $e);
  801. $this->dispatchEvent($failureEvent, DocumentEvents::POST_DELETE_FAILURE);
  802. Logger::error((string) $e);
  804. throw $e;
  805. }
  807. // clear cache
  808. $this->clearDependentCache();
  810. //clear document from registry
  811. RuntimeCache::set(self::getCacheKey($this->getId()), null);
  812. RuntimeCache::set(self::getPathCacheKey($this->getRealFullPath()), null);
  814. $this->dispatchEvent(new DocumentEvent($this), DocumentEvents::POST_DELETE);
  815. }
  817. /**
  818. * {@inheritdoc}
  819. */
  820. public function getFullPath(bool $force = false)
  821. {
  822. $link = $force ? null : $this->fullPathCache;
  824. // check if this document is also the site root, if so return /
  825. try {
  826. if (!$link && \Pimcore\Tool::isFrontend() && Site::isSiteRequest()) {
  827. $site = Site::getCurrentSite();
  828. if ($site instanceof Site) {
  829. if ($site->getRootDocument()->getId() == $this->getId()) {
  830. $link = '/';
  831. }
  832. }
  833. }
  834. } catch (\Exception $e) {
  835. Logger::error((string) $e);
  836. }
  838. $requestStack = \Pimcore::getContainer()->get('request_stack');
  839. $masterRequest = $requestStack->getMainRequest();
  841. // @TODO please forgive me, this is the dirtiest hack I've ever made :(
  842. // if you got confused by this functionality drop me a line and I'll buy you some beers :)
  844. // this is for the case that a link points to a document outside of the current site
  845. // in this case we look for a hardlink in the current site which points to the current document
  846. // why this could happen: we have 2 sites, in one site there's a hardlink to the other site and on a page inside
  847. // the hardlink there are snippets embedded and this snippets have links pointing to a document which is also
  848. // inside the hardlink scope, but this is an ID link, so we cannot rewrite the link the usual way because in the
  849. // snippet / link we don't know anymore that whe a inside a hardlink wrapped document
  850. if (!$link && \Pimcore\Tool::isFrontend() && Site::isSiteRequest() && !FrontendTool::isDocumentInCurrentSite($this)) {
  851. if ($masterRequest && ($masterDocument = $masterRequest->get(DynamicRouter::CONTENT_KEY))) {
  852. if ($masterDocument instanceof WrapperInterface) {
  853. $hardlinkPath = '';
  854. $hardlink = $masterDocument->getHardLinkSource();
  855. $hardlinkTarget = $hardlink->getSourceDocument();
  857. if ($hardlinkTarget) {
  858. $hardlinkPath = preg_replace('@^' . preg_quote(Site::getCurrentSite()->getRootPath(), '@') . '@', '', $hardlink->getRealFullPath());
  860. $link = preg_replace('@^' . preg_quote($hardlinkTarget->getRealFullPath(), '@') . '@',
  861. $hardlinkPath, $this->getRealFullPath());
  862. }
  864. if (strpos($this->getRealFullPath(), Site::getCurrentSite()->getRootDocument()->getRealFullPath()) === false && strpos($link, $hardlinkPath) === false) {
  865. $link = null;
  866. }
  867. }
  868. }
  870. if (!$link) {
  871. $config = \Pimcore\Config::getSystemConfiguration('general');
  872. $request = $requestStack->getCurrentRequest();
  873. $scheme = 'http://';
  874. if ($request) {
  875. $scheme = $request->getScheme() . '://';
  876. }
  878. /** @var Site $site */
  879. if ($site = FrontendTool::getSiteForDocument($this)) {
  880. if ($site->getMainDomain()) {
  881. // check if current document is the root of the different site, if so, preg_replace below doesn't work, so just return /
  882. if ($site->getRootDocument()->getId() == $this->getId()) {
  883. $link = $scheme . $site->getMainDomain() . '/';
  884. } else {
  885. $link = $scheme . $site->getMainDomain() .
  886. preg_replace('@^' . $site->getRootPath() . '/@', '/', $this->getRealFullPath());
  887. }
  888. }
  889. }
  891. if (!$link && !empty($config['domain']) && !($this instanceof WrapperInterface)) {
  892. $link = $scheme . $config['domain'] . $this->getRealFullPath();
  893. }
  894. }
  895. }
  897. if (!$link) {
  898. $link = $this->getPath() . $this->getKey();
  899. }
  901. if ($masterRequest) {
  902. // caching should only be done when master request is available as it is done for performance reasons
  903. // of the web frontend, without a request object there's no need to cache anything
  904. // for details also see https://github.com/pimcore/pimcore/issues/5707
  905. $this->fullPathCache = $link;
  906. }
  908. $link = $this->prepareFrontendPath($link);
  910. return $link;
  911. }
  913. /**
  914. * @param string $path
  915. *
  916. * @return string
  917. */
  918. private function prepareFrontendPath($path)
  919. {
  920. if (\Pimcore\Tool::isFrontend()) {
  921. $path = urlencode_ignore_slash($path);
  923. $event = new GenericEvent($this, [
  924. 'frontendPath' => $path,
  925. ]);
  926. $this->dispatchEvent($event, FrontendEvents::DOCUMENT_PATH);
  927. $path = $event->getArgument('frontendPath');
  928. }
  930. return $path;
  931. }
  933. /**
  934. * {@inheritdoc}
  935. */
  936. public function getKey()
  937. {
  938. return $this->key;
  939. }
  941. /**
  942. * {@inheritdoc}
  943. */
  944. public function getPath()
  945. {
  946. // check for site, if so rewrite the path for output
  947. try {
  948. if (\Pimcore\Tool::isFrontend() && Site::isSiteRequest()) {
  949. $site = Site::getCurrentSite();
  950. if ($site instanceof Site) {
  951. if ($site->getRootDocument() instanceof Document\Page && $site->getRootDocument() !== $this) {
  952. $rootPath = $site->getRootPath();
  953. $rootPath = preg_quote($rootPath, '@');
  954. $link = preg_replace('@^' . $rootPath . '@', '', $this->path);
  956. return $link;
  957. }
  958. }
  959. }
  960. } catch (\Exception $e) {
  961. Logger::error((string) $e);
  962. }
  964. return $this->path;
  965. }
  967. /**
  968. * {@inheritdoc}
  969. */
  970. public function getRealPath()
  971. {
  972. return $this->path;
  973. }
  975. /**
  976. * {@inheritdoc}
  977. */
  978. public function getRealFullPath()
  979. {
  980. $path = $this->getRealPath() . $this->getKey();
  982. return $path;
  983. }
  985. /**
  986. * {@inheritdoc}
  987. */
  988. public function setKey($key)
  989. {
  990. $this->key = (string)$key;
  992. return $this;
  993. }
  995. /**
  996. * Set the parent id of the document.
  997. *
  998. * @param int $parentId
  999. *
  1000. * @return Document
  1001. */
  1002. public function setParentId($parentId)
  1003. {
  1004. parent::setParentId($parentId);
  1006. $this->siblings = [];
  1007. $this->hasSiblings = [];
  1009. return $this;
  1010. }
  1012. /**
  1013. * Returns the document index.
  1014. *
  1015. * @return int|null
  1016. */
  1017. public function getIndex(): ?int
  1018. {
  1019. return $this->index;
  1020. }
  1022. /**
  1023. * Set the document index.
  1024. *
  1025. * @param int $index
  1026. *
  1027. * @return Document
  1028. */
  1029. public function setIndex($index)
  1030. {
  1031. $this->index = (int) $index;
  1033. return $this;
  1034. }
  1036. /**
  1037. * {@inheritdoc}
  1038. */
  1039. public function getType()
  1040. {
  1041. return $this->type;
  1042. }
  1044. /**
  1045. * Set the document type.
  1046. *
  1047. * @param string $type
  1048. *
  1049. * @return Document
  1050. */
  1051. public function setType($type)
  1052. {
  1053. $this->type = $type;
  1055. return $this;
  1056. }
  1058. /**
  1059. * @return bool
  1060. */
  1061. public function isPublished()
  1062. {
  1063. return $this->getPublished();
  1064. }
  1066. /**
  1067. * @return bool
  1068. */
  1069. public function getPublished()
  1070. {
  1071. return (bool) $this->published;
  1072. }
  1074. /**
  1075. * @param bool $published
  1076. *
  1077. * @return Document
  1078. */
  1079. public function setPublished($published)
  1080. {
  1081. $this->published = (bool) $published;
  1083. return $this;
  1084. }
  1086. /**
  1087. * @return Document|null
  1088. */
  1089. public function getParent() /** : ?Document */
  1090. {
  1091. $parent = parent::getParent();
  1093. return $parent instanceof Document ? $parent : null;
  1094. }
  1096. /**
  1097. * Set the parent document instance.
  1098. *
  1099. * @param Document|null $parent
  1100. *
  1101. * @return Document
  1102. */
  1103. public function setParent($parent)
  1104. {
  1105. $this->parent = $parent;
  1106. if ($parent instanceof Document) {
  1107. $this->parentId = $parent->getId();
  1108. }
  1110. return $this;
  1111. }
  1113. /**
  1114. * Set true if want to hide documents.
  1115. *
  1116. * @param bool $hideUnpublished
  1117. */
  1118. public static function setHideUnpublished($hideUnpublished)
  1119. {
  1120. self::$hideUnpublished = $hideUnpublished;
  1121. }
  1123. /**
  1124. * Checks if unpublished documents should be hidden.
  1125. *
  1126. * @return bool
  1127. */
  1128. public static function doHideUnpublished()
  1129. {
  1130. return self::$hideUnpublished;
  1131. }
  1133. /**
  1134. * @internal
  1135. *
  1136. * @param array $args
  1137. *
  1138. * @return string
  1139. */
  1140. protected function getListingCacheKey(array $args = [])
  1141. {
  1142. $includingUnpublished = (bool)($args[0] ?? false);
  1144. return 'document_list_' . ($includingUnpublished ? '1' : '0');
  1145. }
  1147. public function __clone()
  1148. {
  1149. parent::__clone();
  1150. $this->parent = null;
  1151. $this->hasSiblings = [];
  1152. $this->siblings = [];
  1153. $this->fullPathCache = null;
  1154. }
  1155. }