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

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