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

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