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