vendor/pimcore/pimcore/models/Document/Editable/Areablock.php line 32

  1. <?php
  3. /**
  4. * This source file is available under the terms of the
  5. * Pimcore Open Core License (POCL)
  6. * Full copyright and license information is available in
  7. * LICENSE.md which is distributed with this source code.
  8. *
  9. * @copyright Copyright (c) Pimcore GmbH (https://www.pimcore.com)
  10. * @license Pimcore Open Core License (POCL)
  11. */
  13. namespace Pimcore\Model\Document\Editable;
  15. use Exception;
  16. use Generator;
  17. use Pimcore;
  18. use Pimcore\Document\Editable\Block\BlockName;
  19. use Pimcore\Document\Editable\EditableHandler;
  20. use Pimcore\Extension\Document\Areabrick\AreabrickManagerInterface;
  21. use Pimcore\Extension\Document\Areabrick\EditableDialogBoxInterface;
  22. use Pimcore\Model;
  23. use Pimcore\Model\Document;
  24. use Pimcore\Templating\Renderer\EditableRenderer;
  25. use Pimcore\Tool\HtmlUtils;
  27. /**
  28. * @method \Pimcore\Model\Document\Editable\Dao getDao()
  29. */
  30. class Areablock extends Model\Document\Editable implements BlockInterface
  31. {
  32. /**
  33. * Contains an array of indices, which represent the order of the elements in the block
  34. *
  35. * @internal
  36. *
  37. */
  38. protected array $indices = [];
  40. /**
  41. * Current step of the block while iteration
  42. *
  43. * @internal
  44. *
  45. */
  46. protected int $current = 0;
  48. /**
  49. * @internal
  50. *
  51. */
  52. protected ?array $currentIndex = null;
  54. /**
  55. * @internal
  56. *
  57. */
  58. protected ?bool $blockStarted = false;
  60. /**
  61. * @internal
  62. *
  63. */
  64. protected array $brickTypeUsageCounter = [];
  66. public function getType(): string
  67. {
  68. return 'areablock';
  69. }
  71. public function getData(): mixed
  72. {
  73. return $this->indices;
  74. }
  76. public function admin(): void
  77. {
  78. $this->frontend();
  79. }
  81. public function frontend(): void
  82. {
  83. reset($this->indices);
  84. while ($this->loop());
  85. }
  87. /**
  88. * @internal
  89. *
  90. * @return ($return is true ? string : void)
  91. */
  92. public function renderIndex(int $index, bool $return = false)
  93. {
  94. $this->start($return);
  96. $this->currentIndex = $this->indices[$index];
  97. $this->current = $index;
  99. $this->blockConstruct();
  100. $templateParams = $this->blockStart();
  102. $content = $this->content(null, $templateParams, $return);
  103. if (!$return) {
  104. echo $content;
  105. }
  107. $this->blockDestruct();
  108. $this->blockEnd();
  109. $this->end($return);
  111. if ($return) {
  112. return $content;
  113. }
  114. }
  116. public function getIterator(): Generator
  117. {
  118. while ($this->loop()) {
  119. yield $this->getCurrentIndex();
  120. }
  121. }
  123. /**
  124. * @internal
  125. *
  126. */
  127. public function loop(): bool
  128. {
  129. $disabled = false;
  130. $config = $this->getConfig();
  131. $manual = (($config['manual'] ?? false) == true);
  133. if ($this->current > 0) {
  134. if (!$manual && $this->blockStarted) {
  135. $this->blockDestruct();
  136. $this->blockEnd();
  137. }
  138. } else {
  139. if (!$manual) {
  140. $this->start();
  141. }
  142. }
  144. if ($this->current < count($this->indices) && $this->current < $config['limit']) {
  145. $index = current($this->indices);
  146. next($this->indices);
  148. $this->currentIndex = $index;
  149. if (!empty($config['allowed']) && !in_array($index['type'], $config['allowed'])) {
  150. $disabled = true;
  151. }
  153. $brickTypeLimit = $config['limits'][$this->currentIndex['type']] ?? 100000;
  154. $brickTypeUsageCounter = $this->brickTypeUsageCounter[$this->currentIndex['type']] ?? 0;
  155. if ($brickTypeUsageCounter >= $brickTypeLimit) {
  156. $disabled = true;
  157. }
  159. $this->blockStarted = false;
  160. $info = $this->buildInfoObject();
  162. if (!$manual && !$disabled) {
  163. $this->blockConstruct();
  164. $templateParams = $this->blockStart($info);
  166. $this->content($info, $templateParams);
  167. } elseif (!$manual) {
  168. $this->current++;
  169. }
  171. return true;
  172. } else {
  173. if (!$manual) {
  174. $this->end();
  175. }
  177. return false;
  178. }
  179. }
  181. /**
  182. * @internal
  183. *
  184. */
  185. public function buildInfoObject(): Area\Info
  186. {
  187. $config = $this->getConfig();
  188. // create info object and assign it to the view
  189. $info = new Area\Info();
  190. $info->setId($this->currentIndex ? $this->currentIndex['type'] : null);
  191. $info->setEditable($this);
  192. $info->setIndex($this->current);
  194. $params = [];
  195. if (is_array($config['params'][$this->currentIndex['type']] ?? null)) {
  196. $params = $config['params'][$this->currentIndex['type']];
  197. }
  199. if (is_array($config['globalParams'] ?? null)) {
  200. $params = array_merge($config['globalParams'], $params);
  201. }
  203. $info->setParams($params);
  205. return $info;
  206. }
  208. /**
  209. * @param null|Document\Editable\Area\Info $info
  210. *
  211. * @return string|void
  212. */
  213. public function content(?Area\Info $info = null, array $templateParams = [], bool $return = false)
  214. {
  215. if (!$info) {
  216. $info = $this->buildInfoObject();
  217. }
  219. $content = '';
  221. if ($this->editmode || !isset($this->currentIndex['hidden']) || !$this->currentIndex['hidden']) {
  222. $templateParams['isAreaBlock'] = true;
  223. $content = $this->getEditableHandler()->renderAreaFrontend($info, $templateParams);
  224. if (!$return) {
  225. echo $content;
  226. }
  227. $this->brickTypeUsageCounter += [$this->currentIndex['type'] => 0];
  228. $this->brickTypeUsageCounter[$this->currentIndex['type']]++;
  229. }
  231. $this->current++;
  233. if ($return) {
  234. return $content;
  235. }
  236. }
  238. /**
  239. * @internal
  240. *
  241. */
  242. protected function getEditableHandler(): EditableHandler
  243. {
  244. // TODO inject area handler via DI when editables are built through container
  245. return Pimcore::getContainer()->get(EditableHandler::class);
  246. }
  248. public function setDataFromResource(mixed $data): static
  249. {
  250. $unserializedData = $this->getUnserializedData($data) ?? [];
  251. $this->indices = $unserializedData;
  253. return $this;
  254. }
  256. public function setDataFromEditmode(mixed $data): static
  257. {
  258. $this->indices = $data;
  260. return $this;
  261. }
  263. public function blockConstruct(): void
  264. {
  265. // set the current block suffix for the child elements (0, 1, 3, ...)
  266. // this will be removed in blockDestruct
  267. $this->getBlockState()->pushIndex($this->indices[$this->current]['key']);
  268. }
  270. public function blockDestruct(): void
  271. {
  272. $this->getBlockState()->popIndex();
  273. }
  275. private function getToolBarDefaultConfig(): array
  276. {
  277. return [
  278. 'areablock_toolbar' => [
  279. 'width' => 172,
  280. 'buttonWidth' => 168,
  281. 'buttonMaxCharacters' => 20,
  282. ],
  283. ];
  284. }
  286. public function getEditmodeDefinition(): array
  287. {
  288. $config = array_merge($this->getToolBarDefaultConfig(), $this->getConfig());
  290. $options = parent::getEditmodeDefinition();
  291. $options = array_merge($options, [
  292. 'config' => $config,
  293. ]);
  295. return $options;
  296. }
  298. protected function getEditmodeElementAttributes(): array
  299. {
  300. $attributes = parent::getEditmodeElementAttributes();
  302. $attributes = array_merge($attributes, [
  303. 'name' => $this->getName(),
  304. 'type' => $this->getType(),
  305. ]);
  307. return $attributes;
  308. }
  310. public function start(bool $return = false)
  311. {
  312. if (($this->config['manual'] ?? false) === true) {
  313. // in manual mode $this->render() is not called for the areablock, so we need to add
  314. // the editable to the collector manually here
  315. if ($editableDefCollector = $this->getEditableDefinitionCollector()) {
  316. $editableDefCollector->add($this);
  317. }
  318. }
  320. reset($this->indices);
  322. // set name suffix for the whole block element, this will be added to all child elements of the block
  323. $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  325. $attributes = $this->getEditmodeElementAttributes();
  326. $attributeString = HtmlUtils::assembleAttributeString($attributes);
  328. $html = '<div ' . $attributeString . '>';
  330. if ($return) {
  331. return $html;
  332. }
  334. $this->outputEditmode($html);
  336. return $this;
  337. }
  339. public function end(bool $return = false)
  340. {
  341. $this->current = 0;
  343. // remove the current block which was set by $this->start()
  344. $this->getBlockState()->popBlock();
  346. $html = '</div>';
  348. if ($return) {
  349. return $html;
  350. }
  352. $this->outputEditmode($html);
  353. }
  355. public function blockStart(?Area\Info $info = null): array
  356. {
  357. $this->blockStarted = true;
  358. $attributes = [
  359. 'data-name' => $this->getName(),
  360. 'data-real-name' => $this->getRealName(),
  361. ];
  363. $hidden = 'false';
  364. if (isset($this->indices[$this->current]['hidden']) && $this->indices[$this->current]['hidden']) {
  365. $hidden = 'true';
  366. }
  368. $outerAttributes = [
  369. 'key' => $this->indices[$this->current]['key'],
  370. // `data-key` mirrors `key` for editmode consumers: `key` is a reserved
  371. // React prop / non-standard attribute and can be stripped downstream,
  372. // while `data-*` survives. The editmode UI must read `data-key` first.
  373. 'data-key' => $this->indices[$this->current]['key'],
  374. 'type' => $this->indices[$this->current]['type'],
  375. 'data-hidden' => $hidden,
  376. ];
  378. $areabrickManager = Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  380. $dialogConfig = null;
  381. $brick = $areabrickManager->getBrick($this->indices[$this->current]['type']);
  382. if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  383. $dialogConfig = $brick->getEditableDialogBoxConfiguration($this, $info);
  384. if ($dialogConfig->getItems()) {
  385. $dialogConfig->setId('dialogBox-' . $this->getName() . '-' . $this->indices[$this->current]['key']);
  386. } else {
  387. $dialogConfig = null;
  388. }
  389. }
  391. $attr = HtmlUtils::assembleAttributeString($attributes);
  392. $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  394. $dialogAttributes = '';
  395. if ($dialogConfig) {
  396. $dialogAttributes = HtmlUtils::assembleAttributeString([
  397. 'data-dialog-id' => $dialogConfig->getId(),
  398. ]);
  399. }
  401. $dialogHtml = '';
  402. if ($dialogConfig) {
  403. $editableRenderer = Pimcore::getContainer()->get(EditableRenderer::class);
  404. $items = $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer, $dialogConfig->getId(), $dialogHtml);
  405. $dialogConfig->setItems($items);
  406. }
  408. return [
  409. 'editmodeOuterAttributes' => $oAttr,
  410. 'editmodeGenericAttributes' => $attr,
  411. 'editableDialog' => $dialogConfig,
  412. 'editableDialogAttributes' => $dialogAttributes,
  413. 'dialogHtml' => $dialogHtml,
  414. ];
  415. }
  417. /**
  418. * This method needs to be `protected` as it is used in other bundles such as pimcore/headless-documents
  419. *
  420. *
  421. * @throws Exception
  422. *
  423. * @internal
  424. */
  425. protected function renderDialogBoxEditables(array|Document\Editable $config, EditableRenderer $editableRenderer, string $dialogId, string &$html): array
  426. {
  427. if ($config instanceof BlockInterface || $config instanceof Area) {
  428. // Unsupported element was passed (e.g., Block, Areablock, ...)
  429. // or an Areas was passed, which is not supported to avoid too long editable names
  430. throw new Exception(sprintf('Using editables of type "%s" for the editable dialog "%s" is not supported.', get_debug_type($config), $dialogId));
  431. } elseif ($config instanceof Document\Editable) {
  432. // Map editable to array config
  433. $config = [
  434. 'type' => $config->getType(),
  435. 'name' => $config->getName(),
  436. 'label' => $config->getLabel(),
  437. 'config' => $config->getConfig(),
  438. 'description' => $config->getDialogDescription(),
  439. ];
  440. }
  442. if (isset($config['items']) && is_array($config['items'])) {
  443. // layout component
  444. foreach ($config['items'] as $index => $child) {
  445. $config['items'][$index] = $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  446. }
  447. } elseif (isset($config['name']) && isset($config['type'])) {
  448. $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  449. if (!$editable instanceof Document\Editable) {
  450. throw new Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  451. }
  453. $editable->setInDialogBox($dialogId);
  454. $editable->addConfig('dialogBoxConfig', $config);
  455. $html .= $editable->render();
  456. } else {
  457. foreach ($config as $index => $item) {
  458. $config['items'][$index] = $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  459. }
  460. }
  462. return $config;
  463. }
  465. public function blockEnd(): void
  466. {
  467. $this->blockStarted = false;
  468. }
  470. public function setConfig(array $config): static
  471. {
  472. // we need to set this here otherwise custom areaDir's won't work
  473. $this->config = $config;
  475. if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  476. $config['allowed'] = [];
  477. }
  479. $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  480. $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  482. $config['types'] = $availableAreas;
  484. if (isset($config['group']) && is_array($config['group'])) {
  485. $groupingareas = [];
  486. foreach ($availableAreas as $area) {
  487. $groupingareas[$area['type']] = $area['type'];
  488. }
  490. $groups = [];
  491. foreach ($config['group'] as $name => $areas) {
  492. $n = $name;
  493. $groups[$n] = $areas;
  495. foreach ($areas as $area) {
  496. unset($groupingareas[$area]);
  497. }
  498. }
  500. if (count($groupingareas) > 0) {
  501. $uncatAreas = [];
  502. foreach ($groupingareas as $area) {
  503. $uncatAreas[] = $area;
  504. }
  505. $n = 'Uncategorized';
  506. $groups[$n] = $uncatAreas;
  507. }
  509. $config['group'] = $groups;
  510. }
  512. if (empty($config['limit'])) {
  513. $config['limit'] = 1000000;
  514. }
  516. $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  518. $this->config = $config;
  520. if (($this->config['manual'] ?? false) === true) {
  521. $this->config['reload'] = true;
  522. }
  524. return $this;
  525. }
  527. /**
  528. * Sorts areas by index (sorting option) first, then by name
  529. */
  530. private function sortAvailableAreas(array $areas, array $config): array
  531. {
  532. if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  533. $sorting = $config['sorting'];
  534. } else {
  535. if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  536. $sorting = $config['allowed'];
  537. } else {
  538. $sorting = [];
  539. }
  540. }
  542. $result = [
  543. 'name' => [],
  544. 'index' => [],
  545. ];
  547. foreach ($areas as $area) {
  548. $sortIndex = false;
  549. if (!empty($sorting)) {
  550. $sortIndex = array_search($area['type'], $sorting);
  551. }
  553. $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  554. if (false !== $sortIndex) {
  555. $sortKey = 'index';
  556. $area['sortIndex'] = $sortIndex;
  557. }
  559. $result[$sortKey][] = $area;
  560. }
  562. // sort with translated names
  563. if (count($result['name'])) {
  564. usort($result['name'], function ($a, $b) {
  565. if ($a['name'] == $b['name']) {
  566. return 0;
  567. }
  569. return ($a['name'] < $b['name']) ? -1 : 1;
  570. });
  571. }
  573. // sort by allowed brick config order
  574. if (count($result['index'])) {
  575. usort($result['index'], function ($a, $b) {
  576. return $a['sortIndex'] - $b['sortIndex'];
  577. });
  578. }
  580. $result = array_merge($result['index'], $result['name']);
  582. return $result;
  583. }
  585. public function getCount(): int
  586. {
  587. return count($this->indices);
  588. }
  590. public function getCurrent(): int
  591. {
  592. return $this->current - 1;
  593. }
  595. public function getCurrentIndex(): int
  596. {
  597. return $this->indices[$this->getCurrent()]['key'] ?? 0;
  598. }
  600. public function getIndices(): array
  601. {
  602. return $this->indices;
  603. }
  605. /**
  606. * If object was serialized, set the counter back to 0
  607. */
  608. public function __wakeup(): void
  609. {
  610. $this->current = 0;
  611. reset($this->indices);
  612. }
  614. public function isEmpty(): bool
  615. {
  616. return !(bool) count($this->indices);
  617. }
  619. /**
  620. *
  621. * @return Areablock\Item[]
  622. */
  623. public function getElement(string $name): array
  624. {
  625. $document = $this->getDocument();
  627. $parentBlockNames = $this->getParentBlockNames();
  628. $parentBlockNames[] = $this->getName();
  630. $list = [];
  631. foreach ($this->getData() as $index => $item) {
  632. if ($item['type'] === $name) {
  633. $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  634. }
  635. }
  637. return $list;
  638. }
  639. }