vendor/pimcore/pimcore/models/Element/Service.php line 516

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\Element;
  18. use DeepCopy\DeepCopy;
  19. use DeepCopy\Filter\Doctrine\DoctrineCollectionFilter;
  20. use DeepCopy\Filter\SetNullFilter;
  21. use DeepCopy\Matcher\PropertyNameMatcher;
  22. use DeepCopy\Matcher\PropertyTypeMatcher;
  23. use Doctrine\Common\Collections\Collection;
  24. use Doctrine\DBAL\Query\QueryBuilder as DoctrineQueryBuilder;
  25. use Pimcore;
  26. use Pimcore\Db;
  27. use Pimcore\Event\SystemEvents;
  28. use Pimcore\File;
  29. use Pimcore\Helper\CsvFormulaFormatter;
  30. use Pimcore\Logger;
  31. use Pimcore\Model;
  32. use Pimcore\Model\Asset;
  33. use Pimcore\Model\DataObject;
  34. use Pimcore\Model\DataObject\AbstractObject;
  35. use Pimcore\Model\DataObject\ClassDefinition\Data;
  36. use Pimcore\Model\DataObject\Concrete;
  37. use Pimcore\Model\DataObject\ObjectAwareFieldInterface;
  38. use Pimcore\Model\Dependency;
  39. use Pimcore\Model\Document;
  40. use Pimcore\Model\Element\DeepCopy\MarshalMatcher;
  41. use Pimcore\Model\Element\DeepCopy\PimcoreClassDefinitionMatcher;
  42. use Pimcore\Model\Element\DeepCopy\PimcoreClassDefinitionReplaceFilter;
  43. use Pimcore\Model\Element\DeepCopy\UnmarshalMatcher;
  44. use Pimcore\Model\Tool\TmpStore;
  45. use Pimcore\Tool\Serialize;
  46. use Pimcore\Tool\Session;
  47. use Symfony\Component\EventDispatcher\GenericEvent;
  48. use Symfony\Component\OptionsResolver\OptionsResolver;
  49. use Symfony\Contracts\Translation\TranslatorInterface;
  51. /**
  52.  * @method \Pimcore\Model\Element\Dao getDao()
  53.  */
  54. class Service extends Model\AbstractModel
  55. {
  56.     private static ?CsvFormulaFormatter $formatter = null;
  58.     /**
  59.      * @internal
  60.      *
  61.      * @param ElementInterface $element
  62.      *
  63.      * @return string
  64.      */
  65.     public static function getIdPath(ElementInterface $element): string
  66.     {
  67.         $path = '';
  68.         $elementType = self::getElementType($element);
  69.         $parentId = $element->getParentId();
  70.         $parentElement = self::getElementById($elementType, $parentId);
  72.         if ($parentElement) {
  73.             $path = self::getIdPath($parentElement);
  74.         }
  76.         $path .= '/' . $element->getId();
  78.         return $path;
  79.     }
  81.     /**
  82.      * @internal
  83.      *
  84.      * @param ElementInterface $element
  85.      *
  86.      * @return string
  87.      *
  88.      * @throws \Exception
  89.      */
  90.     public static function getTypePath(ElementInterface $element): string
  91.     {
  92.         $path = '';
  93.         $elementType = self::getElementType($element);
  94.         $parentId = $element->getParentId();
  95.         $parentElement = self::getElementById($elementType, $parentId);
  97.         if ($parentElement) {
  98.             $path = self::getTypePath($parentElement);
  99.         }
  101.         $type = $element->getType();
  102.         if ($type !== DataObject::OBJECT_TYPE_FOLDER) {
  103.             if ($element instanceof Document) {
  104.                 $type = 'document';
  105.             } elseif ($element instanceof DataObject\AbstractObject) {
  106.                 $type = 'object';
  107.             } elseif ($element instanceof Asset) {
  108.                 $type = 'asset';
  109.             } else {
  110.                 throw new \Exception('unknown type');
  111.             }
  112.         }
  113.         $path .= '/' . $type;
  115.         return $path;
  116.     }
  118.     /**
  119.      * @internal
  120.      *
  121.      * @param ElementInterface $element
  122.      *
  123.      * @return string
  124.      *
  125.      * @throws \Exception
  126.      */
  127.     public static function getSortIndexPath(ElementInterface $element): string
  128.     {
  129.         $path = '';
  130.         $elementType = self::getElementType($element);
  131.         $parentId = $element->getParentId();
  132.         $parentElement = self::getElementById($elementType, $parentId);
  134.         if ($parentElement) {
  135.             $path = self::getSortIndexPath($parentElement);
  136.         }
  138.         $sortIndex = method_exists($element, 'getIndex') ? (int) $element->getIndex() : 0;
  139.         $path .= '/' . $sortIndex;
  141.         return $path;
  142.     }
  144.     /**
  145.      * @internal
  146.      *
  147.      * @param array|Model\Listing\AbstractListing $list
  148.      * @param string $idGetter
  149.      *
  150.      * @return int[]
  151.      */
  152.     public static function getIdList($list, $idGetter = 'getId')
  153.     {
  154.         $ids = [];
  155.         if (is_array($list)) {
  156.             foreach ($list as $entry) {
  157.                 if (is_object($entry) && method_exists($entry, $idGetter)) {
  158.                     $ids[] = $entry->$idGetter();
  159.                 } elseif (is_scalar($entry)) {
  160.                     $ids[] = $entry;
  161.                 }
  162.             }
  163.         }
  165.         if ($list instanceof Model\Listing\AbstractListing && method_exists($list, 'loadIdList')) {
  166.             $ids = $list->loadIdList();
  167.         }
  168.         $ids = array_unique($ids);
  170.         return $ids;
  171.     }
  173.     /**
  174.      * @param Dependency $d
  175.      * @param int|null $offset
  176.      * @param int|null $limit
  177.      *
  178.      * @return array
  179.      *
  180.      * @internal
  181.      *
  182.      */
  183.     public static function getRequiredByDependenciesForFrontend(Dependency $d, $offset, $limit)
  184.     {
  185.         $dependencies['hasHidden'] = false;
  186.         $dependencies['requiredBy'] = [];
  188.         // requiredBy
  189.         foreach ($d->getRequiredBy($offset, $limit) as $r) {
  190.             if ($e = self::getDependedElement($r)) {
  191.                 if ($e->isAllowed('list')) {
  192.                     $dependencies['requiredBy'][] = self::getDependencyForFrontend($e);
  193.                 } else {
  194.                     $dependencies['hasHidden'] = true;
  195.                 }
  196.             }
  197.         }
  199.         return $dependencies;
  200.     }
  202.     /**
  203.      * @param Dependency $d
  204.      * @param int|null $offset
  205.      * @param int|null $limit
  206.      *
  207.      * @return array
  208.      *
  209.      * @internal
  210.      *
  211.      */
  212.     public static function getRequiresDependenciesForFrontend(Dependency $d, $offset, $limit)
  213.     {
  214.         $dependencies['hasHidden'] = false;
  215.         $dependencies['requires'] = [];
  217.         // requires
  218.         foreach ($d->getRequires($offset, $limit) as $r) {
  219.             if ($e = self::getDependedElement($r)) {
  220.                 if ($e->isAllowed('list')) {
  221.                     $dependencies['requires'][] = self::getDependencyForFrontend($e);
  222.                 } else {
  223.                     $dependencies['hasHidden'] = true;
  224.                 }
  225.             }
  226.         }
  228.         return $dependencies;
  229.     }
  231.     /**
  232.      * @param ElementInterface $element
  233.      *
  234.      * @return array
  235.      */
  236.     private static function getDependencyForFrontend($element)
  237.     {
  238.         return [
  239.             'id' => $element->getId(),
  240.             'path' => $element->getRealFullPath(),
  241.             'type' => self::getElementType($element),
  242.             'subtype' => $element->getType(),
  243.             'published' => self::isPublished($element),
  244.         ];
  245.     }
  247.     /**
  248.      * @param array $config
  249.      *
  250.      * @return DataObject\AbstractObject|Document|Asset|null
  251.      */
  252.     private static function getDependedElement($config)
  253.     {
  254.         if ($config['type'] == 'object') {
  255.             return DataObject::getById($config['id']);
  256.         } elseif ($config['type'] == 'asset') {
  257.             return Asset::getById($config['id']);
  258.         } elseif ($config['type'] == 'document') {
  259.             return Document::getById($config['id']);
  260.         }
  262.         return null;
  263.     }
  265.     /**
  266.      * @param ElementInterface|null $element
  267.      *
  268.      * @return bool
  269.      */
  270.     public static function doHideUnpublished($element)
  271.     {
  272.         return ($element instanceof AbstractObject && DataObject::doHideUnpublished())
  273.             || ($element instanceof Document && Document::doHideUnpublished());
  274.     }
  276.     /**
  277.      * determines whether an element is published
  278.      *
  279.      * @internal
  280.      *
  281.      * @param  ElementInterface $element
  282.      *
  283.      * @return bool
  284.      */
  285.     public static function isPublished($element = null)
  286.     {
  287.         if ($element instanceof ElementInterface) {
  288.             if (method_exists($element, 'isPublished')) {
  289.                 return $element->isPublished();
  290.             } else {
  291.                 return true;
  292.             }
  293.         }
  295.         return false;
  296.     }
  298.     /**
  299.      * @internal
  300.      *
  301.      * @param array|null $data
  302.      *
  303.      * @return array
  304.      *
  305.      * @throws \Exception
  306.      */
  307.     public static function filterUnpublishedAdvancedElements($data): array
  308.     {
  309.         if (DataObject::doHideUnpublished() && is_array($data)) {
  310.             $publishedList = [];
  311.             $mapping = [];
  312.             foreach ($data as $advancedElement) {
  313.                 if (!$advancedElement instanceof DataObject\Data\ObjectMetadata
  314.                     && !$advancedElement instanceof DataObject\Data\ElementMetadata) {
  315.                     throw new \Exception('only supported for advanced many-to-many (+object) relations');
  316.                 }
  318.                 $elementId = null;
  319.                 if ($advancedElement instanceof DataObject\Data\ObjectMetadata) {
  320.                     $elementId = $advancedElement->getObjectId();
  321.                     $elementType = 'object';
  322.                 } else {
  323.                     $elementId = $advancedElement->getElementId();
  324.                     $elementType = $advancedElement->getElementType();
  325.                 }
  327.                 if (!$elementId) {
  328.                     continue;
  329.                 }
  330.                 if ($elementType == 'asset') {
  331.                     // there is no published flag for assets
  332.                     continue;
  333.                 }
  334.                 $mapping[$elementType][$elementId] = true;
  335.             }
  337.             $db = Db::get();
  338.             $publishedMapping = [];
  340.             // now do the query;
  341.             foreach ($mapping as $elementType => $idList) {
  342.                 $idList = array_keys($mapping[$elementType]);
  343.                 switch ($elementType) {
  344.                     case 'document':
  345.                         $idColumn = 'id';
  346.                         $publishedColumn = 'published';
  348.                         break;
  349.                     case 'object':
  350.                         $idColumn = 'o_id';
  351.                         $publishedColumn = 'o_published';
  353.                         break;
  354.                     default:
  355.                         throw new \Exception('unknown type');
  356.                 }
  357.                 $query = 'SELECT ' . $idColumn . ' FROM ' . $elementType . 's WHERE ' . $publishedColumn . '=1 AND ' . $idColumn . ' IN (' . implode(',', $idList) . ');';
  358.                 $publishedIds = $db->fetchFirstColumn($query);
  359.                 $publishedMapping[$elementType] = $publishedIds;
  360.             }
  362.             foreach ($data as $advancedElement) {
  363.                 $elementId = null;
  364.                 if ($advancedElement instanceof DataObject\Data\ObjectMetadata) {
  365.                     $elementId = $advancedElement->getObjectId();
  366.                     $elementType = 'object';
  367.                 } else {
  368.                     $elementId = $advancedElement->getElementId();
  369.                     $elementType = $advancedElement->getElementType();
  370.                 }
  372.                 if ($elementType == 'asset') {
  373.                     $publishedList[] = $advancedElement;
  374.                 }
  376.                 if (isset($publishedMapping[$elementType]) && in_array($elementId, $publishedMapping[$elementType])) {
  377.                     $publishedList[] = $advancedElement;
  378.                 }
  379.             }
  381.             return $publishedList;
  382.         }
  384.         return is_array($data) ? $data : [];
  385.     }
  387.     /**
  388.      * @param  string $type
  389.      * @param  string $path
  390.      *
  391.      * @return ElementInterface|null
  392.      */
  393.     public static function getElementByPath($type, $path)
  394.     {
  395.         $element = null;
  397.         if ($type == 'asset') {
  398.             $element = Asset::getByPath($path);
  399.         } elseif ($type == 'object') {
  400.             $element = DataObject::getByPath($path);
  401.         } elseif ($type == 'document') {
  402.             $element = Document::getByPath($path);
  403.         }
  405.         return $element;
  406.     }
  408.     /**
  409.      * @internal
  410.      *
  411.      * @param string|ElementInterface $element
  412.      *
  413.      * @return string
  414.      *
  415.      * @throws \Exception
  416.      */
  417.     public static function getBaseClassNameForElement($element)
  418.     {
  419.         if ($element instanceof ElementInterface) {
  420.             $elementType = self::getElementType($element);
  421.         } elseif (is_string($element)) {
  422.             $elementType = $element;
  423.         } else {
  424.             throw new \Exception('Wrong type given for getBaseClassNameForElement(), ElementInterface and string are allowed');
  425.         }
  427.         $baseClass = ucfirst($elementType);
  428.         if ($elementType == 'object') {
  429.             $baseClass = 'DataObject';
  430.         }
  432.         return $baseClass;
  433.     }
  435.     /**
  436.      * @deprecated will be removed in Pimcore 11, use getSafeCopyName() instead
  437.      *
  438.      * @param string $type
  439.      * @param string $sourceKey
  440.      * @param ElementInterface $target
  441.      *
  442.      * @return string
  443.      */
  444.     public static function getSaveCopyName($type, $sourceKey, $target)
  445.     {
  446.         trigger_deprecation(
  447.             'pimcore/pimcore',
  448.             '10.0',
  449.             'The Service::getSaveCopyName() method is deprecated, use Service::getSafeCopyName() instead.'
  450.         );
  452.         return self::getSafeCopyName($sourceKey, $target);
  453.     }
  455.     /**
  456.      * Returns a uniqe key for the element in the $target-Path (recursive)
  457.      *
  458.      * @return string
  459.      *
  460.      * @param string $sourceKey
  461.      * @param ElementInterface $target
  462.      */
  463.     public static function getSafeCopyName(string $sourceKey, ElementInterface $target)
  464.     {
  465.         $type = self::getElementType($target);
  466.         if (self::pathExists($target->getRealFullPath() . '/' . $sourceKey, $type)) {
  467.             // only for assets: add the prefix _copy before the file extension (if exist) not after to that source.jpg will be source_copy.jpg and not source.jpg_copy
  468.             if ($type == 'asset' && $fileExtension = File::getFileExtension($sourceKey)) {
  469.                 $sourceKey = preg_replace('/\.' . $fileExtension . '$/i', '_copy.' . $fileExtension, $sourceKey);
  470.             } elseif (preg_match("/_copy(|_\d*)$/", $sourceKey) === 1) {
  471.                 // If key already ends with _copy or copy_N, append a digit to avoid _copy_copy_copy naming
  472.                 $keyParts = explode('_', $sourceKey);
  473.                 $counterKey = array_key_last($keyParts);
  474.                 if ((int)$keyParts[$counterKey] > 0) {
  475.                     $keyParts[$counterKey] = (int)$keyParts[$counterKey] + 1;
  476.                 } else {
  477.                     $keyParts[] = 1;
  478.                 }
  479.                 $sourceKey = implode('_', $keyParts);
  480.             } else {
  481.                 $sourceKey .= '_copy';
  482.             }
  484.             return self::getSafeCopyName($sourceKey, $target);
  485.         }
  487.         return $sourceKey;
  488.     }
  490.     /**
  491.      * @param string $path
  492.      * @param string|null $type
  493.      *
  494.      * @return bool
  495.      */
  496.     public static function pathExists($path, $type = null)
  497.     {
  498.         if ($type == 'asset') {
  499.             return Asset\Service::pathExists($path);
  500.         } elseif ($type == 'document') {
  501.             return Document\Service::pathExists($path);
  502.         } elseif ($type == 'object') {
  503.             return DataObject\Service::pathExists($path);
  504.         }
  506.         return false;
  507.     }
  509.     /**
  510.      * @param  string $type
  511.      * @param  int|string $id
  512.      * @param  array|bool $force
  513.      *
  514.      * @return Asset|AbstractObject|Document|null
  515.      */
  516.     public static function getElementById($type, $id, $force = false)
  517.     {
  518.         $element = null;
  519.         $params = self::prepareGetByIdParams($force, __METHOD__, func_num_args() > 2);
  520.         if ($type === 'asset') {
  521.             $element = Asset::getById($id, $params);
  522.         } elseif ($type === 'object') {
  523.             $element = DataObject::getById($id, $params);
  524.         } elseif ($type === 'document') {
  525.             $element = Document::getById($id, $params);
  526.         }
  528.         return $element;
  529.     }
  531.     /**
  532.      * @internal
  533.      *
  534.      * @param bool|array $params
  535.      *
  536.      * @return array
  537.      */
  538.     public static function prepareGetByIdParams(/*array */$params, string $method, bool $paramsGiven): array
  539.     {
  540.         if (is_bool($params) && $paramsGiven) {
  541.             trigger_deprecation('pimcore/pimcore', '10.5', 'Using $force=%s on %s is deprecated, please use array-syntax [force=>true] instead.', $params ? 'true' : 'false', $method);
  542.             $params = ['force' => $params];
  543.         } elseif ($params === false) {
  544.             $params = [];
  545.         }
  547.         $resolver = new OptionsResolver();
  548.         $resolver->setDefaults([
  549.             'force' => false,
  550.         ]);
  552.         $resolver->setAllowedTypes('force', 'bool');
  554.         return $resolver->resolve($params);
  555.     }
  557.     /**
  558.      * @static
  559.      *
  560.      * @param ElementInterface $element
  561.      *
  562.      * @return string|null
  563.      */
  564.     public static function getElementType($element): ?string
  565.     {
  566.         if ($element instanceof DataObject\AbstractObject) {
  567.             return 'object';
  568.         }
  570.         if ($element instanceof Document) {
  571.             return 'document';
  572.         }
  574.         if ($element instanceof Asset) {
  575.             return 'asset';
  576.         }
  578.         return null;
  579.     }
  581.     /**
  582.      * @internal
  583.      *
  584.      * @param string $className
  585.      *
  586.      * @return string|null
  587.      */
  588.     public static function getElementTypeByClassName(string $className): ?string
  589.     {
  590.         $className = trim($className, '\\');
  591.         if (is_a($className, AbstractObject::class, true)) {
  592.             return 'object';
  593.         }
  594.         if (is_a($className, Asset::class, true)) {
  595.             return 'asset';
  596.         }
  597.         if (is_a($className, Document::class, true)) {
  598.             return 'document';
  599.         }
  601.         return null;
  602.     }
  604.     /**
  605.      * @internal
  606.      *
  607.      * @param ElementInterface $element
  608.      *
  609.      * @return string|null
  610.      */
  611.     public static function getElementHash(ElementInterface $element): ?string
  612.     {
  613.         $elementType = self::getElementType($element);
  614.         if ($elementType === null) {
  615.             return null;
  616.         }
  618.         return $elementType . '-' . $element->getId();
  619.     }
  621.     /**
  622.      * determines the type of an element (object,asset,document)
  623.      *
  624.      * @deprecated use getElementType() instead, will be removed in Pimcore 11
  625.      *
  626.      * @param  ElementInterface $element
  627.      *
  628.      * @return string
  629.      */
  630.     public static function getType($element)
  631.     {
  632.         trigger_deprecation(
  633.             'pimcore/pimcore',
  634.             '10.0',
  635.             'The Service::getType() method is deprecated, use Service::getElementType() instead.'
  636.         );
  638.         return self::getElementType($element);
  639.     }
  641.     /**
  642.      * @internal
  643.      *
  644.      * @param array $props
  645.      *
  646.      * @return array
  647.      */
  648.     public static function minimizePropertiesForEditmode($props)
  649.     {
  650.         $properties = [];
  651.         foreach ($props as $key => $p) {
  652.             //$p = object2array($p);
  653.             $allowedProperties = [
  654.                 'key',
  655.                 'o_key',
  656.                 'filename',
  657.                 'path',
  658.                 'o_path',
  659.                 'id',
  660.                 'o_id',
  661.                 'o_type',
  662.                 'type',
  663.             ];
  665.             if ($p->getData() instanceof Document || $p->getData() instanceof Asset || $p->getData() instanceof DataObject\AbstractObject) {
  666.                 $pa = [];
  668.                 $vars = $p->getData()->getObjectVars();
  670.                 foreach ($vars as $k => $value) {
  671.                     if (in_array($k, $allowedProperties)) {
  672.                         $pa[$k] = $value;
  673.                     }
  674.                 }
  676.                 // clone it because of caching
  677.                 $tmp = clone $p;
  678.                 $tmp->setData($pa);
  679.                 $properties[$key] = $tmp->getObjectVars();
  680.             } else {
  681.                 $properties[$key] = $p->getObjectVars();
  682.             }
  684.             // add config from predefined properties
  685.             if ($p->getName() && $p->getType()) {
  686.                 $predefined = Model\Property\Predefined::getByKey($p->getName());
  688.                 if ($predefined && $predefined->getType() == $p->getType()) {
  689.                     $properties[$key]['config'] = $predefined->getConfig();
  690.                     $properties[$key]['predefinedName'] = $predefined->getName();
  691.                     $properties[$key]['description'] = $predefined->getDescription();
  692.                 }
  693.             }
  694.         }
  696.         return $properties;
  697.     }
  699.     /**
  700.      * @internal
  701.      *
  702.      * @param DataObject|Document|Asset\Folder $target the parent element
  703.      * @param ElementInterface $new the newly inserted child
  704.      */
  705.     protected function updateChildren($target, $new)
  706.     {
  707.         //check in case of recursion
  708.         $found = false;
  709.         foreach ($target->getChildren() as $child) {
  710.             if ($child->getId() == $new->getId()) {
  711.                 $found = true;
  713.                 break;
  714.             }
  715.         }
  716.         if (!$found) {
  717.             $target->setChildren(array_merge($target->getChildren(), [$new]));
  718.         }
  719.     }
  721.     /**
  722.      * @internal
  723.      *
  724.      * @param  ElementInterface $element
  725.      *
  726.      * @return array
  727.      */
  728.     public static function gridElementData(ElementInterface $element)
  729.     {
  730.         $data = [
  731.             'id' => $element->getId(),
  732.             'fullpath' => $element->getRealFullPath(),
  733.             'type' => self::getElementType($element),
  734.             'subtype' => $element->getType(),
  735.             'filename' => $element->getKey(),
  736.             'creationDate' => $element->getCreationDate(),
  737.             'modificationDate' => $element->getModificationDate(),
  738.         ];
  740.         if (method_exists($element, 'isPublished')) {
  741.             $data['published'] = $element->isPublished();
  742.         } else {
  743.             $data['published'] = true;
  744.         }
  746.         return $data;
  747.     }
  749.     /**
  750.      * find all elements which the user may not list and therefore may never be shown to the user.
  751.      * A user may have custom workspaces and/or may inherit those from their role(s), if any.
  752.      *
  753.      * @internal
  754.      *
  755.      * @param string $type asset|object|document
  756.      * @param Model\User $user
  757.      *
  758.      * @return array{forbidden: array, allowed: array}
  759.      */
  760.     public static function findForbiddenPaths($type, $user)
  761.     {
  762.         $db = Db::get();
  764.         if ($user->isAdmin()) {
  765.             return ['forbidden' => [], 'allowed' => ['/']];
  766.         }
  768.         $workspaceCids = [];
  769.         $userWorkspaces = $db->fetchAllAssociative('SELECT cpath, cid, list FROM users_workspaces_' . $type . ' WHERE userId = ?', [$user->getId()]);
  770.         if ($userWorkspaces) {
  771.             // this collects the array that are on user-level, which have top priority
  772.             foreach ($userWorkspaces as $userWorkspace) {
  773.                 $workspaceCids[] = $userWorkspace['cid'];
  774.             }
  775.         }
  777.         if ($userRoleIds = $user->getRoles()) {
  778.             $roleWorkspacesSql = 'SELECT cpath, userid, max(list) as list FROM users_workspaces_' . $type . ' WHERE userId IN (' . implode(',', $userRoleIds) . ')';
  779.             if ($workspaceCids) {
  780.                 $roleWorkspacesSql .= ' AND cid NOT IN (' . implode(',', $workspaceCids) . ')';
  781.             }
  782.             $roleWorkspacesSql .= ' GROUP BY cpath';
  784.             $roleWorkspaces = $db->fetchAllAssociative($roleWorkspacesSql);
  785.         }
  787.         $uniquePaths = [];
  788.         foreach (array_merge($userWorkspaces, $roleWorkspaces ?? []) as $workspace) {
  789.             $uniquePaths[$workspace['cpath']] = $workspace['list'];
  790.         }
  791.         ksort($uniquePaths);
  793.         //TODO: above this should be all in one query (eg. instead of ksort, use sql sort) but had difficulties making the `group by` working properly to let user permissions take precedence
  795.         $totalPaths = count($uniquePaths);
  797.         $forbidden = [];
  798.         $allowed = [];
  799.         if ($totalPaths > 0) {
  800.             $uniquePathsKeys = array_keys($uniquePaths);
  801.             for ($index = 0; $index < $totalPaths; $index++) {
  802.                 $path = $uniquePathsKeys[$index];
  803.                 if ($uniquePaths[$path] == 0) {
  804.                     $forbidden[$path] = [];
  805.                     for ($findIndex = $index + 1; $findIndex < $totalPaths; $findIndex++) { //NB: the starting index is the last index we got
  806.                         $findPath = $uniquePathsKeys[$findIndex];
  807.                         if (str_contains($findPath, $path)) { //it means that we found a children
  808.                             if ($uniquePaths[$findPath] == 1) {
  809.                                 array_push($forbidden[$path], $findPath); //adding list=1 children
  810.                             }
  811.                         } else {
  812.                             break;
  813.                         }
  814.                     }
  815.                 } else {
  816.                     $allowed[] = $path;
  817.                 }
  818.             }
  819.         } else {
  820.             $forbidden['/'] = [];
  821.         }
  823.         return ['forbidden' => $forbidden, 'allowed' => $allowed];
  824.     }
  826.     /**
  827.      * renews all references, for example after unserializing an ElementInterface
  828.      *
  829.      * @internal
  830.      *
  831.      * @param mixed $data
  832.      * @param bool $initial
  833.      * @param string $key
  834.      *
  835.      * @return mixed
  836.      */
  837.     public static function renewReferences($data, $initial = true, $key = null)
  838.     {
  839.         if ($data instanceof \__PHP_Incomplete_Class) {
  840.             Logger::err(sprintf('Renew References: Cannot read data (%s) of incomplete class.', is_null($key) ? 'not available' : $key));
  842.             return null;
  843.         }
  845.         if (is_array($data)) {
  846.             foreach ($data as $dataKey => &$value) {
  847.                 $value = self::renewReferences($value, false, $dataKey);
  848.             }
  850.             return $data;
  851.         }
  852.         if (is_object($data)) {
  853.             if ($data instanceof ElementInterface && !$initial) {
  854.                 return self::getElementById(self::getElementType($data), $data->getId());
  855.             }
  857.             // if this is the initial element set the correct path and key
  858.             if ($data instanceof ElementInterface && !DataObject\AbstractObject::doNotRestoreKeyAndPath()) {
  859.                 $originalElement = self::getElementById(self::getElementType($data), $data->getId());
  861.                 if ($originalElement) {
  862.                     //do not override filename for Assets https://github.com/pimcore/pimcore/issues/8316
  863.                     //                    if ($data instanceof Asset) {
  864.                     //                        /** @var Asset $originalElement */
  865.                     //                        $data->setFilename($originalElement->getFilename());
  866.                     //                    } else
  867.                     if ($data instanceof Document) {
  868.                         /** @var Document $originalElement */
  869.                         $data->setKey($originalElement->getKey());
  870.                     } elseif ($data instanceof DataObject\AbstractObject) {
  871.                         /** @var AbstractObject $originalElement */
  872.                         $data->setKey($originalElement->getKey());
  873.                     }
  875.                     $data->setPath($originalElement->getRealPath());
  876.                 }
  877.             }
  879.             if ($data instanceof Model\AbstractModel) {
  880.                 $properties = $data->getObjectVars();
  881.                 foreach ($properties as $name => $value) {
  882.                     //do not renew object reference of ObjectAwareFieldInterface - as object might point to a
  883.                     //specific version of the object and must not be reloaded with DB version of object
  884.                     if (($data instanceof ObjectAwareFieldInterface || $data instanceof DataObject\Localizedfield) && $name === 'object') {
  885.                         continue;
  886.                     }
  888.                     $data->setObjectVar($name, self::renewReferences($value, false, $name), true);
  889.                 }
  890.             } else {
  891.                 $properties = method_exists($data, 'getObjectVars') ? $data->getObjectVars() : get_object_vars($data);
  892.                 foreach ($properties as $name => $value) {
  893.                     if (method_exists($data, 'setObjectVar')) {
  894.                         $data->setObjectVar($name, self::renewReferences($value, false, $name), true);
  895.                     } else {
  896.                         $data->$name = self::renewReferences($value, false, $name);
  897.                     }
  898.                 }
  899.             }
  901.             return $data;
  902.         }
  904.         return $data;
  905.     }
  907.     /**
  908.      * @internal
  909.      *
  910.      * @param string $path
  911.      *
  912.      * @return string
  913.      */
  914.     public static function correctPath(string $path): string
  915.     {
  916.         // remove trailing slash
  917.         if ($path !== '/') {
  918.             $path = rtrim($path, '/ ');
  919.         }
  921.         // correct wrong path (root-node problem)
  922.         $path = str_replace('//', '/', $path);
  924.         if (str_contains($path, '%')) {
  925.             $path = rawurldecode($path);
  926.         }
  928.         return $path;
  929.     }
  931.     /**
  932.      * @internal
  933.      *
  934.      * @param ElementInterface $element
  935.      *
  936.      * @return ElementInterface
  937.      */
  938.     public static function loadAllFields(ElementInterface $element): ElementInterface
  939.     {
  940.         if ($element instanceof Document) {
  941.             Document\Service::loadAllDocumentFields($element);
  942.         } elseif ($element instanceof DataObject\Concrete) {
  943.             DataObject\Service::loadAllObjectFields($element);
  944.         } elseif ($element instanceof Asset) {
  945.             Asset\Service::loadAllFields($element);
  946.         }
  948.         return $element;
  949.     }
  951.     /** Callback for array_filter function.
  952.      * @param string $var value
  953.      *
  954.      * @return bool true if value is accepted
  955.      */
  956.     private static function filterNullValues($var)
  957.     {
  958.         return strlen($var) > 0;
  959.     }
  961.     /**
  962.      * @param string $path
  963.      * @param array $options
  964.      *
  965.      * @return Asset\Folder|Document\Folder|DataObject\Folder
  966.      *
  967.      * @throws \Exception
  968.      */
  969.     public static function createFolderByPath($path, $options = [])
  970.     {
  971.         $calledClass = static::class;
  972.         if ($calledClass === __CLASS__) {
  973.             throw new \Exception('This method must be called from a extended class. e.g Asset\\Service, DataObject\\Service, Document\\Service');
  974.         }
  976.         $type = str_replace('\Service', '', $calledClass);
  977.         $type = '\\' . ltrim($type, '\\');
  978.         $folderType = $type . '\Folder';
  980.         $lastFolder = null;
  981.         $pathsArray = [];
  982.         $parts = explode('/', $path);
  983.         $parts = array_filter($parts, '\\Pimcore\\Model\\Element\\Service::filterNullValues');
  985.         $sanitizedPath = '/';
  987.         $itemType = self::getElementType(new $type);
  989.         foreach ($parts as $part) {
  990.             $sanitizedPath = $sanitizedPath . self::getValidKey($part, $itemType) . '/';
  991.         }
  993.         if (self::pathExists($sanitizedPath, $itemType)) {
  994.             return $type::getByPath($sanitizedPath);
  995.         }
  997.         foreach ($parts as $part) {
  998.             $pathPart = $pathsArray[count($pathsArray) - 1] ?? '';
  999.             $pathsArray[] = $pathPart . '/' . self::getValidKey($part, $itemType);
  1000.         }
  1002.         for ($i = 0; $i < count($pathsArray); $i++) {
  1003.             $currentPath = $pathsArray[$i];
  1004.             if (!self::pathExists($currentPath, $itemType)) {
  1005.                 $parentFolderPath = ($i == 0) ? '/' : $pathsArray[$i - 1];
  1007.                 $parentFolder = $type::getByPath($parentFolderPath);
  1009.                 $folder = new $folderType();
  1010.                 $folder->setParent($parentFolder);
  1011.                 if ($parentFolder) {
  1012.                     $folder->setParentId($parentFolder->getId());
  1013.                 } else {
  1014.                     $folder->setParentId(1);
  1015.                 }
  1017.                 $key = substr($currentPath, strrpos($currentPath, '/') + 1, strlen($currentPath));
  1019.                 if (method_exists($folder, 'setKey')) {
  1020.                     $folder->setKey($key);
  1021.                 }
  1023.                 if (method_exists($folder, 'setFilename')) {
  1024.                     $folder->setFilename($key);
  1025.                 }
  1027.                 if (method_exists($folder, 'setType')) {
  1028.                     $folder->setType('folder');
  1029.                 }
  1031.                 $folder->setPath($currentPath);
  1032.                 $folder->setUserModification(0);
  1033.                 $folder->setUserOwner(1);
  1034.                 $folder->setCreationDate(time());
  1035.                 $folder->setModificationDate(time());
  1036.                 $folder->setValues($options);
  1037.                 $folder->save();
  1038.                 $lastFolder = $folder;
  1039.             }
  1040.         }
  1042.         return $lastFolder;
  1043.     }
  1045.     /**
  1046.      * Changes the query according to the custom view config
  1047.      *
  1048.      * @internal
  1049.      *
  1050.      * @param array $cv
  1051.      * @param Model\Asset\Listing|Model\DataObject\Listing|Model\Document\Listing $childsList
  1052.      */
  1053.     public static function addTreeFilterJoins($cv, $childsList)
  1054.     {
  1055.         if ($cv) {
  1056.             $childsList->onCreateQueryBuilder(static function (DoctrineQueryBuilder $select) use ($cv) {
  1057.                 $where = $cv['where'] ?? null;
  1058.                 if ($where) {
  1059.                     $select->andWhere($where);
  1060.                 }
  1062.                 $fromAlias = $select->getQueryPart('from')[0]['alias'] ?? $select->getQueryPart('from')[0]['table'] ;
  1064.                 $customViewJoins = $cv['joins'] ?? null;
  1065.                 if ($customViewJoins) {
  1066.                     foreach ($customViewJoins as $joinConfig) {
  1067.                         $type = $joinConfig['type'];
  1068.                         $method = $type == 'left' || $type == 'right' ? $method = $type . 'Join' : 'join';
  1070.                         $joinAlias = array_keys($joinConfig['name']);
  1071.                         $joinAlias = reset($joinAlias);
  1072.                         $joinTable = $joinConfig['name'][$joinAlias];
  1074.                         $condition = $joinConfig['condition'];
  1075.                         $columns = $joinConfig['columns'];
  1076.                         $select->addSelect($columns);
  1077.                         $select->$method($fromAlias, $joinTable, $joinAlias, $condition);
  1078.                     }
  1079.                 }
  1081.                 if (!empty($cv['having'])) {
  1082.                     $select->having($cv['having']);
  1083.                 }
  1084.             });
  1085.         }
  1086.     }
  1088.     /**
  1089.      * @internal
  1090.      *
  1091.      * @param string $id
  1092.      *
  1093.      * @return array|null
  1094.      */
  1095.     public static function getCustomViewById($id)
  1096.     {
  1097.         $customViews = \Pimcore\CustomView\Config::get();
  1098.         if ($customViews) {
  1099.             foreach ($customViews as $customView) {
  1100.                 if ($customView['id'] == $id) {
  1101.                     return $customView;
  1102.                 }
  1103.             }
  1104.         }
  1106.         return null;
  1107.     }
  1109.     /**
  1110.      * @param string $key
  1111.      * @param string $type
  1112.      *
  1113.      * @return string
  1114.      */
  1115.     public static function getValidKey($key, $type)
  1116.     {
  1117.         $event = new GenericEvent(null, [
  1118.             'key' => $key,
  1119.             'type' => $type,
  1120.         ]);
  1121.         \Pimcore::getEventDispatcher()->dispatch($event, SystemEvents::SERVICE_PRE_GET_VALID_KEY);
  1122.         $key = $event->getArgument('key');
  1123.         $key = trim($key);
  1125.         // replace all 4 byte unicode characters
  1126.         $key = preg_replace('/[\x{10000}-\x{10FFFF}]/u', '-', $key);
  1127.         // replace left to right marker characters ( lrm )
  1128.         $key = preg_replace('/(\x{200e}|\x{200f})/u', '-', $key);
  1129.         // replace slashes with a hyphen
  1130.         $key = str_replace('/', '-', $key);
  1132.         if ($type === 'object') {
  1133.             $key = preg_replace('/[<>]/', '-', $key);
  1134.         } elseif ($type === 'document') {
  1135.             // replace URL reserved characters with a hyphen
  1136.             $key = preg_replace('/[#\?\*\:\\\\<\>\|"%&@=;\+]/', '-', $key);
  1137.         } elseif ($type === 'asset') {
  1138.             // keys shouldn't start with a "." (=hidden file) *nix operating systems
  1139.             // keys shouldn't end with a "." - Windows issue: filesystem API trims automatically . at the end of a folder name (no warning ... et al)
  1140.             $key = trim($key, '. ');
  1142.             // windows forbidden filenames + URL reserved characters (at least the ones which are problematic)
  1143.             $key = preg_replace('/[#\?\*\:\\\\<\>\|"%\+]/', '-', $key);
  1144.         } else {
  1145.             $key = ltrim($key, '. ');
  1146.         }
  1148.         // key should not end (or start) with space after cut
  1149.         return trim(mb_substr($key, 0, 255));
  1150.     }
  1152.     /**
  1153.      * @param string $key
  1154.      * @param string $type
  1155.      *
  1156.      * @return bool
  1157.      */
  1158.     public static function isValidKey($key, $type)
  1159.     {
  1160.         return self::getValidKey($key, $type) == $key;
  1161.     }
  1163.     /**
  1164.      * @param string $path
  1165.      * @param string $type
  1166.      *
  1167.      * @return bool
  1168.      */
  1169.     public static function isValidPath($path, $type)
  1170.     {
  1171.         $parts = explode('/', $path);
  1172.         foreach ($parts as $part) {
  1173.             if (!self::isValidKey($part, $type)) {
  1174.                 return false;
  1175.             }
  1176.         }
  1178.         return true;
  1179.     }
  1181.     /**
  1182.      * returns a unique key for an element
  1183.      *
  1184.      * @param ElementInterface $element
  1185.      *
  1186.      * @return string|null
  1187.      */
  1188.     public static function getUniqueKey($element)
  1189.     {
  1190.         if ($element instanceof DataObject\AbstractObject) {
  1191.             return DataObject\Service::getUniqueKey($element);
  1192.         }
  1194.         if ($element instanceof Document) {
  1195.             return Document\Service::getUniqueKey($element);
  1196.         }
  1198.         if ($element instanceof Asset) {
  1199.             return Asset\Service::getUniqueKey($element);
  1200.         }
  1202.         return null;
  1203.     }
  1205.     /**
  1206.      * @internal
  1207.      *
  1208.      * @param array $data
  1209.      * @param string $type
  1210.      *
  1211.      * @return array
  1212.      */
  1213.     public static function fixAllowedTypes($data, $type)
  1214.     {
  1215.         // this is the new method with Ext.form.MultiSelect
  1216.         if (is_array($data) && count($data)) {
  1217.             $first = reset($data);
  1218.             if (!is_array($first)) {
  1219.                 $parts = $data;
  1220.                 $data = [];
  1221.                 foreach ($parts as $elementType) {
  1222.                     $data[] = [$type => $elementType];
  1223.                 }
  1224.             } else {
  1225.                 $newList = [];
  1226.                 foreach ($data as $key => $item) {
  1227.                     if ($item) {
  1228.                         if (is_array($item)) {
  1229.                             foreach ($item as $itemKey => $itemValue) {
  1230.                                 if ($itemValue) {
  1231.                                     $newList[$key][$itemKey] = $itemValue;
  1232.                                 }
  1233.                             }
  1234.                         } else {
  1235.                             $newList[$key] = $item;
  1236.                         }
  1237.                     }
  1238.                 }
  1240.                 $data = $newList;
  1241.             }
  1242.         }
  1244.         return $data ? $data : [];
  1245.     }
  1247.     /**
  1248.      * @internal
  1249.      *
  1250.      * @param Model\Version[] $versions
  1251.      *
  1252.      * @return array
  1253.      */
  1254.     public static function getSafeVersionInfo($versions)
  1255.     {
  1256.         $indexMap = [];
  1257.         $result = [];
  1259.         if (is_array($versions)) {
  1260.             foreach ($versions as $versionObj) {
  1261.                 $version = [
  1262.                     'id' => $versionObj->getId(),
  1263.                     'cid' => $versionObj->getCid(),
  1264.                     'ctype' => $versionObj->getCtype(),
  1265.                     'note' => $versionObj->getNote(),
  1266.                     'date' => $versionObj->getDate(),
  1267.                     'public' => $versionObj->getPublic(),
  1268.                     'versionCount' => $versionObj->getVersionCount(),
  1269.                     'autoSave' => $versionObj->isAutoSave(),
  1270.                 ];
  1272.                 $version['user'] = ['name' => '', 'id' => ''];
  1273.                 if ($user = $versionObj->getUser()) {
  1274.                     $version['user'] = [
  1275.                         'name' => $user->getName(),
  1276.                         'id' => $user->getId(),
  1277.                     ];
  1278.                 }
  1280.                 $versionKey = $versionObj->getDate() . '-' . $versionObj->getVersionCount();
  1281.                 if (!isset($indexMap[$versionKey])) {
  1282.                     $indexMap[$versionKey] = 0;
  1283.                 }
  1284.                 $version['index'] = $indexMap[$versionKey];
  1285.                 $indexMap[$versionKey] = $indexMap[$versionKey] + 1;
  1287.                 $result[] = $version;
  1288.             }
  1289.         }
  1291.         return $result;
  1292.     }
  1294.     /**
  1295.      * @param ElementInterface $element
  1296.      *
  1297.      * @return ElementInterface
  1298.      */
  1299.     public static function cloneMe(ElementInterface $element)
  1300.     {
  1301.         $deepCopy = new \DeepCopy\DeepCopy();
  1302.         $deepCopy->addFilter(new \DeepCopy\Filter\KeepFilter(), new class() implements \DeepCopy\Matcher\Matcher {
  1303.             /**
  1304.              * {@inheritdoc}
  1305.              */
  1306.             public function matches($object, $property)
  1307.             {
  1308.                 try {
  1309.                     $reflectionProperty = new \ReflectionProperty($object, $property);
  1310.                     $reflectionProperty->setAccessible(true);
  1311.                     $myValue = $reflectionProperty->getValue($object);
  1312.                 } catch (\Throwable $e) {
  1313.                     return false;
  1314.                 }
  1316.                 return $myValue instanceof ElementInterface;
  1317.             }
  1318.         });
  1320.         if ($element instanceof Concrete) {
  1321.             $deepCopy->addFilter(
  1322.                 new PimcoreClassDefinitionReplaceFilter(
  1323.                     function (Concrete $object, Data $fieldDefinition, $property, $currentValue) {
  1324.                         if ($fieldDefinition instanceof Data\CustomDataCopyInterface) {
  1325.                             return $fieldDefinition->createDataCopy($object, $currentValue);
  1326.                         }
  1328.                         return $currentValue;
  1329.                     }
  1330.                 ),
  1331.                 new PimcoreClassDefinitionMatcher(Data\CustomDataCopyInterface::class)
  1332.             );
  1333.         }
  1335.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('dao'));
  1336.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('resource'));
  1337.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('writeResource'));
  1338.         $deepCopy->addFilter(new \DeepCopy\Filter\Doctrine\DoctrineCollectionFilter(), new \DeepCopy\Matcher\PropertyTypeMatcher(
  1339.             Collection::class
  1340.         ));
  1342.         if ($element instanceof DataObject\Concrete) {
  1343.             DataObject\Service::loadAllObjectFields($element);
  1344.         }
  1346.         $theCopy = $deepCopy->copy($element);
  1347.         $theCopy->setId(null);
  1348.         $theCopy->setParent(null);
  1350.         return $theCopy;
  1351.     }
  1353.     /**
  1354.      * @template T
  1355.      *
  1356.      * @param T $properties
  1357.      *
  1358.      * @return T
  1359.      */
  1360.     public static function cloneProperties(mixed $properties): mixed
  1361.     {
  1362.         $deepCopy = new \DeepCopy\DeepCopy();
  1363.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('cid'));
  1364.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('ctype'));
  1365.         $deepCopy->addFilter(new SetNullFilter(), new PropertyNameMatcher('cpath'));
  1367.         return $deepCopy->copy($properties);
  1368.     }
  1370.     /**
  1371.      * @internal
  1372.      *
  1373.      * @param Note $note
  1374.      *
  1375.      * @return array
  1376.      */
  1377.     public static function getNoteData(Note $note)
  1378.     {
  1379.         $cpath = '';
  1380.         if ($note->getCid() && $note->getCtype()) {
  1381.             if ($element = Service::getElementById($note->getCtype(), $note->getCid())) {
  1382.                 $cpath = $element->getRealFullPath();
  1383.             }
  1384.         }
  1386.         $e = [
  1387.             'id' => $note->getId(),
  1388.             'type' => $note->getType(),
  1389.             'cid' => $note->getCid(),
  1390.             'ctype' => $note->getCtype(),
  1391.             'cpath' => $cpath,
  1392.             'date' => $note->getDate(),
  1393.             'title' => Pimcore::getContainer()->get(TranslatorInterface::class)->trans($note->getTitle(), [], 'admin'),
  1394.             'description' => $note->getDescription(),
  1395.         ];
  1397.         // prepare key-values
  1398.         $keyValues = [];
  1399.         if (is_array($note->getData())) {
  1400.             foreach ($note->getData() as $name => $d) {
  1401.                 $type = $d['type'];
  1402.                 $data = $d['data'];
  1404.                 if ($type == 'document' || $type == 'object' || $type == 'asset') {
  1405.                     if ($d['data'] instanceof ElementInterface) {
  1406.                         $data = [
  1407.                             'id' => $d['data']->getId(),
  1408.                             'path' => $d['data']->getRealFullPath(),
  1409.                             'type' => $d['data']->getType(),
  1410.                         ];
  1411.                     }
  1412.                 } elseif ($type == 'date') {
  1413.                     if (is_object($d['data'])) {
  1414.                         $data = $d['data']->getTimestamp();
  1415.                     }
  1416.                 }
  1418.                 $keyValue = [
  1419.                     'type' => $type,
  1420.                     'name' => $name,
  1421.                     'data' => $data,
  1422.                 ];
  1424.                 $keyValues[] = $keyValue;
  1425.             }
  1426.         }
  1428.         $e['data'] = $keyValues;
  1430.         // prepare user data
  1431.         if ($note->getUser()) {
  1432.             $user = Model\User::getById($note->getUser());
  1433.             if ($user) {
  1434.                 $e['user'] = [
  1435.                     'id' => $user->getId(),
  1436.                     'name' => $user->getName(),
  1437.                 ];
  1438.             } else {
  1439.                 $e['user'] = '';
  1440.             }
  1441.         }
  1443.         return $e;
  1444.     }
  1446.     /**
  1447.      * @internal
  1448.      *
  1449.      * @param string $type
  1450.      * @param int $elementId
  1451.      * @param null|string $postfix
  1452.      *
  1453.      * @return string
  1454.      */
  1455.     public static function getSessionKey($type, $elementId, $postfix = '')
  1456.     {
  1457.         $sessionId = Session::getSessionId();
  1458.         $tmpStoreKey = $type . '_session_' . $elementId . '_' . $sessionId . $postfix;
  1460.         return $tmpStoreKey;
  1461.     }
  1463.     /**
  1464.      *
  1465.      * @param string $type
  1466.      * @param int $elementId
  1467.      * @param null|string $postfix
  1468.      *
  1469.      * @return AbstractObject|Document|Asset|null
  1470.      */
  1471.     public static function getElementFromSession($type, $elementId, $postfix = '')
  1472.     {
  1473.         $element = null;
  1474.         $tmpStoreKey = self::getSessionKey($type, $elementId, $postfix);
  1476.         $tmpStore = TmpStore::get($tmpStoreKey);
  1477.         if ($tmpStore) {
  1478.             $data = $tmpStore->getData();
  1479.             if ($data) {
  1480.                 $element = Serialize::unserialize($data);
  1482.                 $context = [
  1483.                     'source' => __METHOD__,
  1484.                     'conversion' => 'unmarshal',
  1485.                 ];
  1487.                 $copier = Self::getDeepCopyInstance($element, $context);
  1489.                 if ($element instanceof Concrete) {
  1490.                     $copier->addFilter(
  1491.                         new PimcoreClassDefinitionReplaceFilter(
  1492.                             function (Concrete $object, Data $fieldDefinition, $property, $currentValue) {
  1493.                                 if ($fieldDefinition instanceof Data\CustomVersionMarshalInterface) {
  1494.                                     return $fieldDefinition->unmarshalVersion($object, $currentValue);
  1495.                                 }
  1497.                                 return $currentValue;
  1498.                             }
  1499.                         ),
  1500.                         new PimcoreClassDefinitionMatcher(Data\CustomVersionMarshalInterface::class)
  1501.                     );
  1502.                 }
  1504.                 return $copier->copy($element);
  1505.             }
  1506.         }
  1508.         return $element;
  1509.     }
  1511.     /**
  1512.      * @internal
  1513.      *
  1514.      * @param ElementInterface $element
  1515.      * @param string $postfix
  1516.      * @param bool $clone save a copy
  1517.      */
  1518.     public static function saveElementToSession($element, $postfix = '', $clone = true)
  1519.     {
  1520.         self::loadAllFields($element);
  1522.         if ($clone) {
  1523.             $context = [
  1524.                 'source' => __METHOD__,
  1525.                 'conversion' => 'marshal',
  1526.             ];
  1527.             $copier = self::getDeepCopyInstance($element, $context);
  1529.             if ($element instanceof Concrete) {
  1530.                 $copier->addFilter(
  1531.                     new PimcoreClassDefinitionReplaceFilter(
  1532.                         function (Concrete $object, Data $fieldDefinition, $property, $currentValue) {
  1533.                             if ($fieldDefinition instanceof Data\CustomVersionMarshalInterface) {
  1534.                                 return $fieldDefinition->marshalVersion($object, $currentValue);
  1535.                             }
  1537.                             return $currentValue;
  1538.                         }
  1539.                     ),
  1540.                     new PimcoreClassDefinitionMatcher(Data\CustomVersionMarshalInterface::class)
  1541.                 );
  1542.             }
  1544.             $copier->addFilter(new Model\Version\SetDumpStateFilter(true), new \DeepCopy\Matcher\PropertyMatcher(Model\Element\ElementDumpStateInterface::class, Model\Element\ElementDumpStateInterface::DUMP_STATE_PROPERTY_NAME));
  1545.             $element = $copier->copy($element);
  1546.         }
  1548.         $elementType = Service::getElementType($element);
  1549.         $tmpStoreKey = self::getSessionKey($elementType, $element->getId(), $postfix);
  1550.         $tag = $elementType . '-session' . $postfix;
  1552.         $element->setInDumpState(true);
  1553.         $serializedData = Serialize::serialize($element);
  1555.         TmpStore::set($tmpStoreKey, $serializedData, $tag);
  1556.     }
  1558.     /**
  1559.      * @internal
  1560.      *
  1561.      * @param string $type
  1562.      * @param int $elementId
  1563.      * @param string $postfix
  1564.      */
  1565.     public static function removeElementFromSession($type, $elementId, $postfix = '')
  1566.     {
  1567.         $tmpStoreKey = self::getSessionKey($type, $elementId, $postfix);
  1568.         TmpStore::delete($tmpStoreKey);
  1569.     }
  1571.     /**
  1572.      * @internal
  1573.      *
  1574.      * @param mixed $element
  1575.      * @param array|null $context
  1576.      *
  1577.      * @return DeepCopy
  1578.      */
  1579.     public static function getDeepCopyInstance($element, ?array $context = []): DeepCopy
  1580.     {
  1581.         $copier = new DeepCopy();
  1582.         $copier->skipUncloneable(true);
  1584.         if ($element instanceof ElementInterface) {
  1585.             if (($context['conversion'] ?? false) === 'marshal') {
  1586.                 $sourceType = Service::getElementType($element);
  1587.                 $sourceId = $element->getId();
  1589.                 $copier->addTypeFilter(
  1590.                     new \DeepCopy\TypeFilter\ReplaceFilter(
  1591.                         function ($currentValue) {
  1592.                             if ($currentValue instanceof ElementInterface) {
  1593.                                 $elementType = Service::getElementType($currentValue);
  1594.                                 $descriptor = new ElementDescriptor($elementType, $currentValue->getId());
  1596.                                 return $descriptor;
  1597.                             }
  1599.                             return $currentValue;
  1600.                         }
  1601.                     ),
  1602.                     new MarshalMatcher($sourceType, $sourceId)
  1603.                 );
  1604.             } elseif (($context['conversion'] ?? false) === 'unmarshal') {
  1605.                 $copier->addTypeFilter(
  1606.                     new \DeepCopy\TypeFilter\ReplaceFilter(
  1607.                         function ($currentValue) {
  1608.                             if ($currentValue instanceof ElementDescriptor) {
  1609.                                 $value = Service::getElementById($currentValue->getType(), $currentValue->getId());
  1611.                                 return $value;
  1612.                             }
  1614.                             return $currentValue;
  1615.                         }
  1616.                     ),
  1617.                     new UnmarshalMatcher()
  1618.                 );
  1619.             }
  1620.         }
  1622.         if ($context['defaultFilters'] ?? false) {
  1623.             $copier->addFilter(new DoctrineCollectionFilter(), new PropertyTypeMatcher('Doctrine\Common\Collections\Collection'));
  1624.             $copier->addFilter(new SetNullFilter(), new PropertyTypeMatcher('Psr\Container\ContainerInterface'));
  1625.             $copier->addFilter(new SetNullFilter(), new PropertyTypeMatcher('Pimcore\Model\DataObject\ClassDefinition'));
  1626.         }
  1628.         $event = new GenericEvent(null, [
  1629.             'copier' => $copier,
  1630.             'element' => $element,
  1631.             'context' => $context,
  1632.         ]);
  1634.         \Pimcore::getEventDispatcher()->dispatch($event, SystemEvents::SERVICE_PRE_GET_DEEP_COPY);
  1636.         return $event->getArgument('copier');
  1637.     }
  1639.     /**
  1640.      * @internal
  1641.      *
  1642.      * @param array $rowData
  1643.      *
  1644.      * @return array
  1645.      */
  1646.     public static function escapeCsvRecord(array $rowData): array
  1647.     {
  1648.         if (self::$formatter === null) {
  1649.             self::$formatter = new CsvFormulaFormatter("'", ['=', '-', '+', '@']);
  1650.         }
  1651.         $rowData = self::$formatter->escapeRecord($rowData);
  1653.         return $rowData;
  1654.     }
  1656.     /**
  1657.      * @internal
  1658.      */
  1659.     public static function unEscapeCsvField(string $value): string
  1660.     {
  1661.         if (self::$formatter === null) {
  1662.             self::$formatter = new CsvFormulaFormatter("'", ['=', '-', '+', '@']);
  1663.         }
  1664.         $value = self::$formatter->unEscapeField($value);
  1666.         return $value;
  1667.     }
  1669.     /**
  1670.      * @internal
  1671.      *
  1672.      * @param string $type
  1673.      * @param int|string|null $id
  1674.      *
  1675.      * @return string
  1676.      */
  1677.     public static function getElementCacheTag(string $type, $id): string
  1678.     {
  1679.         return $type . '_' . $id;
  1680.     }
  1681. }