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

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