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

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\Loader\ImplementationLoader\Exception\UnsupportedException;
  24. use Pimcore\Logger;
  25. use Pimcore\Model\Document\Hardlink\Wrapper\WrapperInterface;
  26. use Pimcore\Model\Document\Listing;
  27. use Pimcore\Model\Element\DuplicateFullPathException;
  28. use Pimcore\Model\Exception\NotFoundException;
  29. use Pimcore\Tool;
  30. use Pimcore\Tool\Frontend as FrontendTool;
  31. use Symfony\Cmf\Bundle\RoutingBundle\Routing\DynamicRouter;
  32. use Symfony\Component\EventDispatcher\GenericEvent;
  34. /**
  35.  * @method \Pimcore\Model\Document\Dao getDao()
  36.  * @method bool __isBasedOnLatestData()
  37.  * @method int getChildAmount($user = null)
  38.  * @method string getCurrentFullPath()
  39.  */
  40. class Document extends Element\AbstractElement
  41. {
  42.     /**
  43.      * all possible types of documents
  44.      *
  45.      * @internal
  46.      *
  47.      * @deprecated will be removed in Pimcore 11. Use getTypes() method.
  48.      *
  49.      * @var array
  50.      */
  51.     public static $types = ['folder', 'page', 'snippet', 'link', 'hardlink', 'email', 'newsletter', 'printpage', 'printcontainer'];
  53.     /**
  54.      * @var bool
  55.      */
  56.     private static $hideUnpublished = false;
  58.     /**
  59.      * @internal
  60.      *
  61.      * @var string|null
  62.      */
  63.     protected $fullPathCache;
  65.     /**
  66.      * @internal
  67.      *
  68.      * @var string
  69.      */
  70.     protected string $type = '';
  72.     /**
  73.      * @internal
  74.      *
  75.      * @var string|null
  76.      */
  77.     protected $key;
  79.     /**
  80.      * @internal
  81.      *
  82.      * @var string|null
  83.      */
  84.     protected $path;
  86.     /**
  87.      * @internal
  88.      *
  89.      * @var int|null
  90.      */
  91.     protected ?int $index = null;
  93.     /**
  94.      * @internal
  95.      *
  96.      * @var bool
  97.      */
  98.     protected bool $published = true;
  100.     /**
  101.      * @internal
  102.      *
  103.      * @var int|null
  104.      */
  105.     protected ?int $userModification = null;
  107.     /**
  108.      * @internal
  109.      *
  110.      * @var array
  111.      */
  112.     protected $children = [];
  114.     /**
  115.      * @internal
  116.      *
  117.      * @var bool[]
  118.      */
  119.     protected $hasChildren = [];
  121.     /**
  122.      * @internal
  123.      *
  124.      * @var array
  125.      */
  126.     protected $siblings = [];
  128.     /**
  129.      * @internal
  130.      *
  131.      * @var bool[]
  132.      */
  133.     protected $hasSiblings = [];
  135.     /**
  136.      * {@inheritdoc}
  137.      */
  138.     protected function getBlockedVars(): array
  139.     {
  140.         $blockedVars = ['hasChildren', 'versions', 'scheduledTasks', 'parent', 'fullPathCache'];
  142.         if (!$this->isInDumpState()) {
  143.             // this is if we want to cache the object
  144.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  145.         }
  147.         return $blockedVars;
  148.     }
  150.     /**
  151.      * get possible types
  152.      *
  153.      * @return array
  154.      */
  155.     public static function getTypes()
  156.     {
  157.         $documentsConfig = \Pimcore\Config::getSystemConfiguration('documents');
  159.         return $documentsConfig['types'];
  160.     }
  162.     /**
  163.      * @internal
  164.      *
  165.      * @param string $path
  166.      *
  167.      * @return string
  168.      */
  169.     protected static function getPathCacheKey(string $path): string
  170.     {
  171.         return 'document_path_' . md5($path);
  172.     }
  174.     /**
  175.      * @param string $path
  176.      * @param array|bool $force
  177.      *
  178.      * @return static|null
  179.      */
  180.     public static function getByPath($path, $force = false)
  181.     {
  182.         if (!$path) {
  183.             return null;
  184.         }
  186.         $path = Element\Service::correctPath($path);
  188.         $cacheKey = self::getPathCacheKey($path);
  189.         $params = Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  191.         if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  192.             $document = RuntimeCache::get($cacheKey);
  193.             if ($document && static::typeMatch($document)) {
  194.                 return $document;
  195.             }
  196.         }
  198.         try {
  199.             $helperDoc = new Document();
  200.             $helperDoc->getDao()->getByPath($path);
  201.             $doc = static::getById($helperDoc->getId(), $params);
  202.             RuntimeCache::set($cacheKey, $doc);
  203.         } catch (NotFoundException $e) {
  204.             $doc = null;
  205.         }
  207.         return $doc;
  208.     }
  210.     /**
  211.      * @internal
  212.      *
  213.      * @param Document $document
  214.      *
  215.      * @return bool
  216.      */
  217.     protected static function typeMatch(Document $document)
  218.     {
  219.         $staticType = static::class;
  220.         if ($staticType !== Document::class) {
  221.             if (!$document instanceof $staticType) {
  222.                 return false;
  223.             }
  224.         }
  226.         return true;
  227.     }
  229.     /**
  230.      * @param int|string $id
  231.      * @param array|bool $force
  232.      *
  233.      * @return static|null
  234.      */
  235.     public static function getById($id, $force = false)
  236.     {
  237.         if (!is_numeric($id) || $id < 1) {
  238.             return null;
  239.         }
  241.         $id = (int)$id;
  242.         $cacheKey = self::getCacheKey($id);
  243.         $params = Element\Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  245.         if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  246.             $document = RuntimeCache::get($cacheKey);
  247.             if ($document && static::typeMatch($document)) {
  248.                 return $document;
  249.             }
  250.         }
  252.         if ($params['force'] || !($document = \Pimcore\Cache::load($cacheKey))) {
  253.             $reflectionClass = new \ReflectionClass(static::class);
  254.             if ($reflectionClass->isAbstract()) {
  255.                 $document = new Document();
  256.             } else {
  257.                 $document = new static();
  258.             }
  260.             try {
  261.                 $document->getDao()->getById($id);
  262.             } catch (NotFoundException $e) {
  263.                 return null;
  264.             }
  266.             try {
  267.                 // Getting classname from document resolver
  269.                 if(!$className = \Pimcore::getContainer()->get('pimcore.class.resolver.document')->resolve($document->getType())) {
  270.                     throw new UnsupportedException();
  271.                 }
  272.             } catch(UnsupportedException $ex) {
  273.                 trigger_deprecation(
  274.                     'pimcore/pimcore',
  275.                     '10.6.0',
  276.                     sprintf('%s - Loading documents via fixed namespace is deprecated and will be removed in Pimcore 11. Use pimcore:type_definitions instead', $ex->getMessage())
  277.                 );
  278.                 /**
  279.                  * @deprecated since Pimcore 10.6 and will be removed in Pimcore 11. Use type_definitions instead
  280.                  */
  281.                 $className = 'Pimcore\\Model\\Document\\' . ucfirst($document->getType());
  283.                 // this is the fallback for custom document types using prefixes
  284.                 // so we need to check if the class exists first
  285.                 if (!Tool::classExists($className)) {
  286.                     $oldStyleClass = 'Document_' . ucfirst($document->getType());
  287.                     if (Tool::classExists($oldStyleClass)) {
  288.                         $className = $oldStyleClass;
  289.                     }
  290.                 }
  291.             }
  293.             /** @var Document $newDocument */
  294.             $newDocument = self::getModelFactory()->build($className);
  296.             if (get_class($document) !== get_class($newDocument)) {
  297.                 $document = $newDocument;
  298.                 $document->getDao()->getById($id);
  299.             }
  301.             RuntimeCache::set($cacheKey, $document);
  302.             $document->__setDataVersionTimestamp($document->getModificationDate());
  304.             $document->resetDirtyMap();
  306.             \Pimcore\Cache::save($document, $cacheKey);
  307.         } else {
  308.             RuntimeCache::set($cacheKey, $document);
  309.         }
  311.         if (!$document || !static::typeMatch($document)) {
  312.             return null;
  313.         }
  315.         \Pimcore::getEventDispatcher()->dispatch(
  316.             new DocumentEvent($document, ['params' => $params]),
  317.             DocumentEvents::POST_LOAD
  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.                 $this->dispatchEvent($preEvent, DocumentEvents::PRE_UPDATE);
  392.             } else {
  393.                 $this->dispatchEvent($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 !== $newPath = $this->getRealFullPath()) {
  426.                         $differentOldPath = $oldPath;
  427.                         $this->getDao()->updateWorkspaces();
  428.                         $updatedChildren = array_map(
  429.                             static function (array $doc) use ($oldPath, $newPath): array {
  430.                                 $doc['oldPath'] = substr_replace($doc['path'], $oldPath, 0, strlen($newPath));
  432.                                 return $doc;
  433.                             },
  434.                             $this->getDao()->updateChildPaths($oldPath),
  435.                         );
  436.                     }
  438.                     $this->commit();
  440.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  441.                 } catch (\Exception $e) {
  442.                     try {
  443.                         $this->rollBack();
  444.                     } catch (\Exception $er) {
  445.                         // PDO adapter throws exceptions if rollback fails
  446.                         Logger::error((string) $er);
  447.                     }
  449.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  450.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  451.                         $run = $retries + 1;
  452.                         $waitTime = rand(1, 5) * 100000; // microseconds
  453.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  455.                         usleep($waitTime); // wait specified time until we restart the transaction
  456.                     } else {
  457.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  458.                         throw $e;
  459.                     }
  460.                 }
  461.             }
  463.             $additionalTags = [];
  464.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  465.                 foreach ($updatedChildren as $updatedDocument) {
  466.                     $tag = self::getCacheKey($updatedDocument['id']);
  467.                     $additionalTags[] = $tag;
  469.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long-running scripts, such as CLI
  470.                     RuntimeCache::set($tag, null);
  471.                     RuntimeCache::set(self::getPathCacheKey($updatedDocument['oldPath']), null);
  472.                 }
  473.             }
  474.             $this->clearDependentCache($additionalTags);
  476.             $postEvent = new DocumentEvent($this, $params);
  477.             if ($isUpdate) {
  478.                 if ($differentOldPath) {
  479.                     $postEvent->setArgument('oldPath', $differentOldPath);
  480.                 }
  481.                 $this->dispatchEvent($postEvent, DocumentEvents::POST_UPDATE);
  482.             } else {
  483.                 $this->dispatchEvent($postEvent, DocumentEvents::POST_ADD);
  484.             }
  486.             return $this;
  487.         } catch (\Exception $e) {
  488.             $failureEvent = new DocumentEvent($this, $params);
  489.             $failureEvent->setArgument('exception', $e);
  490.             if ($isUpdate) {
  491.                 $this->dispatchEvent($failureEvent, DocumentEvents::POST_UPDATE_FAILURE);
  492.             } else {
  493.                 $this->dispatchEvent($failureEvent, DocumentEvents::POST_ADD_FAILURE);
  494.             }
  496.             throw $e;
  497.         }
  498.     }
  500.     /**
  501.      * @throws \Exception|DuplicateFullPathException
  502.      */
  503.     private function correctPath()
  504.     {
  505.         // set path
  506.         if ($this->getId() != 1) { // not for the root node
  507.             // check for a valid key, home has no key, so omit the check
  508.             if (!Element\Service::isValidKey($this->getKey(), 'document')) {
  509.                 throw new \Exception('invalid key for document with id [ ' . $this->getId() . ' ] key is: [' . $this->getKey() . ']');
  510.             }
  512.             if ($this->getParentId() == $this->getId()) {
  513.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  514.             }
  516.             $parent = Document::getById($this->getParentId());
  517.             if ($parent) {
  518.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  519.                 // that is currently in the parent object (in memory), because this might have changed but wasn't not saved
  520.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  521.             } else {
  522.                 trigger_deprecation(
  523.                     'pimcore/pimcore',
  524.                     '10.5',
  525.                     'Fallback for parentId will be removed in Pimcore 11.',
  526.                 );
  527.                 // parent document doesn't exist anymore, set the parent to to root
  528.                 $this->setParentId(1);
  529.                 $this->setPath('/');
  530.             }
  532.             if (strlen($this->getKey()) < 1) {
  533.                 throw new \Exception('Document requires key, generated key automatically');
  534.             }
  535.         } elseif ($this->getId() == 1) {
  536.             // some data in root node should always be the same
  537.             $this->setParentId(0);
  538.             $this->setPath('/');
  539.             $this->setKey('');
  540.             $this->setType('page');
  541.         }
  543.         if (Document\Service::pathExists($this->getRealFullPath())) {
  544.             $duplicate = Document::getByPath($this->getRealFullPath());
  545.             if ($duplicate instanceof Document && $duplicate->getId() != $this->getId()) {
  546.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save document');
  547.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  549.                 throw $duplicateFullPathException;
  550.             }
  551.         }
  553.         $this->validatePathLength();
  554.     }
  556.     /**
  557.      * @internal
  558.      *
  559.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  560.      *
  561.      * @throws \Exception
  562.      */
  563.     protected function update($params = [])
  564.     {
  565.         $disallowedKeysInFirstLevel = ['install', 'admin', 'plugin'];
  566.         if ($this->getParentId() == 1 && in_array($this->getKey(), $disallowedKeysInFirstLevel)) {
  567.             throw new \Exception('Key: ' . $this->getKey() . ' is not allowed in first level (root-level)');
  568.         }
  570.         // set index if null
  571.         if ($this->getIndex() === null) {
  572.             $this->setIndex($this->getDao()->getNextIndex());
  573.         }
  575.         // save properties
  576.         $this->getProperties();
  577.         $this->getDao()->deleteAllProperties();
  578.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  579.             foreach ($this->getProperties() as $property) {
  580.                 if (!$property->getInherited()) {
  581.                     $property->setDao(null);
  582.                     $property->setCid($this->getId());
  583.                     $property->setCtype('document');
  584.                     $property->setCpath($this->getRealFullPath());
  585.                     $property->save();
  586.                 }
  587.             }
  588.         }
  590.         // save dependencies
  591.         $d = new Dependency();
  592.         $d->setSourceType('document');
  593.         $d->setSourceId($this->getId());
  595.         foreach ($this->resolveDependencies() as $requirement) {
  596.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'document') {
  597.                 // dont't add a reference to yourself
  598.                 continue;
  599.             } else {
  600.                 $d->addRequirement($requirement['id'], $requirement['type']);
  601.             }
  602.         }
  603.         $d->save();
  605.         $this->getDao()->update();
  607.         //set document to registry
  608.         RuntimeCache::set(self::getCacheKey($this->getId()), $this);
  609.     }
  611.     /**
  612.      * @internal
  613.      *
  614.      * @param int $index
  615.      */
  616.     public function saveIndex($index)
  617.     {
  618.         $this->getDao()->saveIndex($index);
  619.         $this->clearDependentCache();
  620.     }
  622.     /**
  623.      * {@inheritdoc}
  624.      */
  625.     public function clearDependentCache($additionalTags = [])
  626.     {
  627.         try {
  628.             $tags = [$this->getCacheTag(), 'document_properties', 'output'];
  629.             $tags = array_merge($tags, $additionalTags);
  631.             \Pimcore\Cache::clearTags($tags);
  632.         } catch (\Exception $e) {
  633.             Logger::crit((string) $e);
  634.         }
  635.     }
  637.     /**
  638.      * set the children of the document
  639.      *
  640.      * @param Document[]|null $children
  641.      * @param bool $includingUnpublished
  642.      *
  643.      * @return $this
  644.      */
  645.     public function setChildren($children, $includingUnpublished = false)
  646.     {
  647.         if ($children === null) {
  648.             // unset all cached children
  649.             $this->hasChildren = [];
  650.             $this->children = [];
  651.         } elseif (is_array($children)) {
  652.             $cacheKey = $this->getListingCacheKey([$includingUnpublished]);
  653.             $this->children[$cacheKey] = $children;
  654.             $this->hasChildren[$cacheKey] = (bool) count($children);
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * Get a list of the children (not recursivly)
  662.      *
  663.      * @param bool $includingUnpublished
  664.      *
  665.      * @return self[]
  666.      */
  667.     public function getChildren($includingUnpublished = false)
  668.     {
  669.         $cacheKey = $this->getListingCacheKey(func_get_args());
  671.         if (!isset($this->children[$cacheKey])) {
  672.             if ($this->getId()) {
  673.                 $list = new Document\Listing();
  674.                 $list->setUnpublished($includingUnpublished);
  675.                 $list->setCondition('parentId = ?', $this->getId());
  676.                 $list->setOrderKey('index');
  677.                 $list->setOrder('asc');
  678.                 $this->children[$cacheKey] = $list->load();
  679.             } else {
  680.                 $this->children[$cacheKey] = [];
  681.             }
  682.         }
  684.         return $this->children[$cacheKey];
  685.     }
  687.     /**
  688.      * Returns true if the document has at least one child
  689.      *
  690.      * @param bool $includingUnpublished
  691.      *
  692.      * @return bool
  693.      */
  694.     public function hasChildren($includingUnpublished = null)
  695.     {
  696.         $cacheKey = $this->getListingCacheKey(func_get_args());
  698.         if (isset($this->hasChildren[$cacheKey])) {
  699.             return $this->hasChildren[$cacheKey];
  700.         }
  702.         return $this->hasChildren[$cacheKey] = $this->getDao()->hasChildren($includingUnpublished);
  703.     }
  705.     /**
  706.      * Get a list of the sibling documents
  707.      *
  708.      * @param bool $includingUnpublished
  709.      *
  710.      * @return array
  711.      */
  712.     public function getSiblings($includingUnpublished = false)
  713.     {
  714.         $cacheKey = $this->getListingCacheKey(func_get_args());
  716.         if (!isset($this->siblings[$cacheKey])) {
  717.             if ($this->getParentId()) {
  718.                 $list = new Document\Listing();
  719.                 $list->setUnpublished($includingUnpublished);
  720.                 $list->addConditionParam('parentId = ?', $this->getParentId());
  721.                 if ($this->getId()) {
  722.                     $list->addConditionParam('id != ?', $this->getId());
  723.                 }
  724.                 $list->setOrderKey('index');
  725.                 $list->setOrder('asc');
  726.                 $this->siblings[$cacheKey] = $list->load();
  727.                 $this->hasSiblings[$cacheKey] = (bool) count($this->siblings[$cacheKey]);
  728.             } else {
  729.                 $this->siblings[$cacheKey] = [];
  730.                 $this->hasSiblings[$cacheKey] = false;
  731.             }
  732.         }
  734.         return $this->siblings[$cacheKey];
  735.     }
  737.     /**
  738.      * Returns true if the document has at least one sibling
  739.      *
  740.      * @param bool|null $includingUnpublished
  741.      *
  742.      * @return bool
  743.      */
  744.     public function hasSiblings($includingUnpublished = null)
  745.     {
  746.         $cacheKey = $this->getListingCacheKey(func_get_args());
  748.         if (isset($this->hasSiblings[$cacheKey])) {
  749.             return $this->hasSiblings[$cacheKey];
  750.         }
  752.         return $this->hasSiblings[$cacheKey] = $this->getDao()->hasSiblings($includingUnpublished);
  753.     }
  755.     /**
  756.      * @internal
  757.      *
  758.      * @throws \Exception
  759.      */
  760.     protected function doDelete()
  761.     {
  762.         // remove children
  763.         if ($this->hasChildren()) {
  764.             // delete also unpublished children
  765.             $unpublishedStatus = self::doHideUnpublished();
  766.             self::setHideUnpublished(false);
  767.             foreach ($this->getChildren(true) as $child) {
  768.                 if (!$child instanceof WrapperInterface) {
  769.                     $child->delete();
  770.                 }
  771.             }
  772.             self::setHideUnpublished($unpublishedStatus);
  773.         }
  775.         // remove all properties
  776.         $this->getDao()->deleteAllProperties();
  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.         $this->dispatchEvent(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 (RuntimeCache::isRegistered($parentCacheKey)) {
  809.                 /** @var Document $parent */
  810.                 $parent = RuntimeCache::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.             $this->dispatchEvent($failureEvent, DocumentEvents::POST_DELETE_FAILURE);
  820.             Logger::error((string) $e);
  822.             throw $e;
  823.         }
  825.         // clear cache
  826.         $this->clearDependentCache();
  828.         //clear document from registry
  829.         RuntimeCache::set(self::getCacheKey($this->getId()), null);
  830.         RuntimeCache::set(self::getPathCacheKey($this->getRealFullPath()), null);
  832.         $this->dispatchEvent(new DocumentEvent($this), DocumentEvents::POST_DELETE);
  833.     }
  835.     /**
  836.      * {@inheritdoc}
  837.      */
  838.     public function getFullPath(bool $force = false)
  839.     {
  840.         $link = $force ? null : $this->fullPathCache;
  842.         // check if this document is also the site root, if so return /
  843.         try {
  844.             if (!$link && Tool::isFrontend() && Site::isSiteRequest()) {
  845.                 $site = Site::getCurrentSite();
  846.                 if ($site instanceof Site) {
  847.                     if ($site->getRootDocument()->getId() == $this->getId()) {
  848.                         $link = '/';
  849.                     }
  850.                 }
  851.             }
  852.         } catch (\Exception $e) {
  853.             Logger::error((string) $e);
  854.         }
  856.         $requestStack = \Pimcore::getContainer()->get('request_stack');
  857.         $mainRequest = $requestStack->getMainRequest();
  858.         $request = $requestStack->getCurrentRequest();
  860.         // @TODO please forgive me, this is the dirtiest hack I've ever made :(
  861.         // if you got confused by this functionality drop me a line and I'll buy you some beers :)
  863.         // this is for the case that a link points to a document outside of the current site
  864.         // in this case we look for a hardlink in the current site which points to the current document
  865.         // why this could happen: we have 2 sites, in one site there's a hardlink to the other site and on a page inside
  866.         // the hardlink there are snippets embedded and this snippets have links pointing to a document which is also
  867.         // inside the hardlink scope, but this is an ID link, so we cannot rewrite the link the usual way because in the
  868.         // snippet / link we don't know anymore that whe a inside a hardlink wrapped document
  869.         if (!$link && Tool::isFrontend()) {
  870.             $differentDomain = false;
  871.             $site = FrontendTool::getSiteForDocument($this);
  872.             if (Tool::isFrontendRequestByAdmin() && $site instanceof Site) {
  873.                 $differentDomain = $site->getMainDomain() != $request->getHost();
  874.             }
  876.             if ((Site::isSiteRequest() && !FrontendTool::isDocumentInCurrentSite($this))
  877.                 || $differentDomain) {
  878.                 if ($mainRequest && ($mainDocument = $mainRequest->get(DynamicRouter::CONTENT_KEY))) {
  879.                     if ($mainDocument instanceof WrapperInterface) {
  880.                         $hardlinkPath = '';
  881.                         $hardlink = $mainDocument->getHardLinkSource();
  882.                         $hardlinkTarget = $hardlink->getSourceDocument();
  884.                         if ($hardlinkTarget) {
  885.                             $hardlinkPath = preg_replace('@^' . preg_quote(Site::getCurrentSite()->getRootPath(), '@') . '@', '', $hardlink->getRealFullPath());
  887.                             $link = preg_replace('@^' . preg_quote($hardlinkTarget->getRealFullPath(), '@') . '@',
  888.                                 $hardlinkPath, $this->getRealFullPath());
  889.                         }
  891.                         if (strpos($this->getRealFullPath(), Site::getCurrentSite()->getRootDocument()->getRealFullPath()) === false && strpos($link, $hardlinkPath) === false) {
  892.                             $link = null;
  893.                         }
  894.                     }
  895.                 }
  897.                 if (!$link) {
  898.                     $config = \Pimcore\Config::getSystemConfiguration('general');
  899.                     $scheme = 'http://';
  900.                     if ($request) {
  901.                         $scheme = $request->getScheme() . '://';
  902.                     }
  904.                     if ($site) {
  905.                         if ($site->getMainDomain()) {
  906.                             // check if current document is the root of the different site, if so, preg_replace below doesn't work, so just return /
  907.                             if ($site->getRootDocument()->getId() == $this->getId()) {
  908.                                 $link = $scheme . $site->getMainDomain() . '/';
  909.                             } else {
  910.                                 $link = $scheme . $site->getMainDomain() .
  911.                                     preg_replace('@^' . $site->getRootPath() . '/@', '/', $this->getRealFullPath());
  912.                             }
  913.                         }
  914.                     }
  916.                     if (!$link && !empty($config['domain']) && !($this instanceof WrapperInterface)) {
  917.                         $link = $scheme . $config['domain'] . $this->getRealFullPath();
  918.                     }
  919.                 }
  920.             }
  921.         }
  923.         if (!$link) {
  924.             $link = $this->getPath() . $this->getKey();
  925.         }
  927.         if ($mainRequest) {
  928.             // caching should only be done when main request is available as it is done for performance reasons
  929.             // of the web frontend, without a request object there's no need to cache anything
  930.             // for details also see https://github.com/pimcore/pimcore/issues/5707
  931.             $this->fullPathCache = $link;
  932.         }
  934.         $link = $this->prepareFrontendPath($link);
  936.         return $link;
  937.     }
  939.     /**
  940.      * @param string $path
  941.      *
  942.      * @return string
  943.      */
  944.     private function prepareFrontendPath($path)
  945.     {
  946.         if (Tool::isFrontend()) {
  947.             $path = urlencode_ignore_slash($path);
  949.             $event = new GenericEvent($this, [
  950.                 'frontendPath' => $path,
  951.             ]);
  952.             $this->dispatchEvent($event, FrontendEvents::DOCUMENT_PATH);
  953.             $path = $event->getArgument('frontendPath');
  954.         }
  956.         return $path;
  957.     }
  959.     /**
  960.      * {@inheritdoc}
  961.      */
  962.     public function getKey()
  963.     {
  964.         return $this->key;
  965.     }
  967.     /**
  968.      * {@inheritdoc}
  969.      */
  970.     public function getPath()
  971.     {
  972.         // check for site, if so rewrite the path for output
  973.         try {
  974.             if (Tool::isFrontend() && Site::isSiteRequest()) {
  975.                 $site = Site::getCurrentSite();
  976.                 if ($site instanceof Site) {
  977.                     if ($site->getRootDocument() instanceof Document\Page && $site->getRootDocument() !== $this) {
  978.                         $rootPath = $site->getRootPath();
  979.                         $rootPath = preg_quote($rootPath, '@');
  980.                         $link = preg_replace('@^' . $rootPath . '@', '', $this->path);
  982.                         return $link;
  983.                     }
  984.                 }
  985.             }
  986.         } catch (\Exception $e) {
  987.             Logger::error((string) $e);
  988.         }
  990.         return $this->path;
  991.     }
  993.     /**
  994.      * {@inheritdoc}
  995.      */
  996.     public function getRealPath()
  997.     {
  998.         return $this->path;
  999.     }
  1001.     /**
  1002.      * {@inheritdoc}
  1003.      */
  1004.     public function getRealFullPath()
  1005.     {
  1006.         $path = $this->getRealPath() . $this->getKey();
  1008.         return $path;
  1009.     }
  1011.     /**
  1012.      * {@inheritdoc}
  1013.      */
  1014.     public function setKey($key)
  1015.     {
  1016.         $this->key = (string)$key;
  1018.         return $this;
  1019.     }
  1021.     /**
  1022.      * Set the parent id of the document.
  1023.      *
  1024.      * @param int $parentId
  1025.      *
  1026.      * @return Document
  1027.      */
  1028.     public function setParentId($parentId)
  1029.     {
  1030.         parent::setParentId($parentId);
  1032.         $this->siblings = [];
  1033.         $this->hasSiblings = [];
  1035.         return $this;
  1036.     }
  1038.     /**
  1039.      * Returns the document index.
  1040.      *
  1041.      * @return int|null
  1042.      */
  1043.     public function getIndex(): ?int
  1044.     {
  1045.         return $this->index;
  1046.     }
  1048.     /**
  1049.      * Set the document index.
  1050.      *
  1051.      * @param int $index
  1052.      *
  1053.      * @return Document
  1054.      */
  1055.     public function setIndex($index)
  1056.     {
  1057.         $this->index = (int) $index;
  1059.         return $this;
  1060.     }
  1062.     /**
  1063.      * {@inheritdoc}
  1064.      */
  1065.     public function getType()
  1066.     {
  1067.         return $this->type;
  1068.     }
  1070.     /**
  1071.      * Set the document type.
  1072.      *
  1073.      * @param string $type
  1074.      *
  1075.      * @return Document
  1076.      */
  1077.     public function setType($type)
  1078.     {
  1079.         $this->type = $type;
  1081.         return $this;
  1082.     }
  1084.     /**
  1085.      * @return bool
  1086.      */
  1087.     public function isPublished()
  1088.     {
  1089.         return $this->getPublished();
  1090.     }
  1092.     /**
  1093.      * @return bool
  1094.      */
  1095.     public function getPublished()
  1096.     {
  1097.         return (bool) $this->published;
  1098.     }
  1100.     /**
  1101.      * @param bool $published
  1102.      *
  1103.      * @return Document
  1104.      */
  1105.     public function setPublished($published)
  1106.     {
  1107.         $this->published = (bool) $published;
  1109.         return $this;
  1110.     }
  1112.     /**
  1113.      * @return Document|null
  1114.      */
  1115.     public function getParent() /** : ?Document */
  1116.     {
  1117.         $parent = parent::getParent();
  1119.         return $parent instanceof Document ? $parent : null;
  1120.     }
  1122.     /**
  1123.      * Set the parent document instance.
  1124.      *
  1125.      * @param Document|null $parent
  1126.      *
  1127.      * @return Document
  1128.      */
  1129.     public function setParent($parent)
  1130.     {
  1131.         $this->parent = $parent;
  1132.         if ($parent instanceof Document) {
  1133.             $this->parentId = $parent->getId();
  1134.         }
  1136.         return $this;
  1137.     }
  1139.     /**
  1140.      * Set true if want to hide documents.
  1141.      *
  1142.      * @param bool $hideUnpublished
  1143.      */
  1144.     public static function setHideUnpublished($hideUnpublished)
  1145.     {
  1146.         self::$hideUnpublished = $hideUnpublished;
  1147.     }
  1149.     /**
  1150.      * Checks if unpublished documents should be hidden.
  1151.      *
  1152.      * @return bool
  1153.      */
  1154.     public static function doHideUnpublished()
  1155.     {
  1156.         return self::$hideUnpublished;
  1157.     }
  1159.     /**
  1160.      * @internal
  1161.      *
  1162.      * @param array $args
  1163.      *
  1164.      * @return string
  1165.      */
  1166.     protected function getListingCacheKey(array $args = [])
  1167.     {
  1168.         $includingUnpublished = (bool)($args[0] ?? false);
  1170.         return 'document_list_' . ($includingUnpublished ? '1' : '0');
  1171.     }
  1173.     public function __clone()
  1174.     {
  1175.         parent::__clone();
  1176.         $this->parent = null;
  1177.         $this->hasSiblings = [];
  1178.         $this->siblings = [];
  1179.         $this->fullPathCache = null;
  1180.     }
  1181. }