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

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\Document\Editable;
  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;
  26. use Pimcore\Tool\HtmlUtils;
  28. /**
  29. * @method \Pimcore\Model\Document\Editable\Dao getDao()
  30. */
  31. class Areablock extends Model\Document\Editable implements BlockInterface
  32. {
  33. /**
  34. * Contains an array of indices, which represent the order of the elements in the block
  35. *
  36. * @internal
  37. *
  38. * @var array
  39. */
  40. protected $indices = [];
  42. /**
  43. * Current step of the block while iteration
  44. *
  45. * @internal
  46. *
  47. * @var int
  48. */
  49. protected $current = 0;
  51. /**
  52. * @internal
  53. *
  54. * @var array|null
  55. */
  56. protected $currentIndex;
  58. /**
  59. * @internal
  60. *
  61. * @var bool|null
  62. */
  63. protected $blockStarted;
  65. /**
  66. * @internal
  67. *
  68. * @var array
  69. */
  70. protected $brickTypeUsageCounter = [];
  72. /**
  73. * {@inheritdoc}
  74. */
  75. public function getType()
  76. {
  77. return 'areablock';
  78. }
  80. /**
  81. * {@inheritdoc}
  82. */
  83. public function getData()
  84. {
  85. return $this->indices;
  86. }
  88. /**
  89. * {@inheritdoc}
  90. */
  91. public function admin()
  92. {
  93. $this->frontend();
  94. }
  96. /**
  97. * {@inheritdoc}
  98. */
  99. public function frontend()
  100. {
  101. if (!is_array($this->indices)) {
  102. $this->indices = [];
  103. }
  104. reset($this->indices);
  105. while ($this->loop());
  106. }
  108. /**
  109. * @internal
  110. *
  111. * @param int $index
  112. * @param bool $return
  113. */
  114. public function renderIndex($index, $return = false)
  115. {
  116. $this->start($return);
  118. $this->currentIndex = $this->indices[$index];
  119. $this->current = $index;
  121. $this->blockConstruct();
  122. $templateParams = $this->blockStart();
  124. $content = $this->content(null, $templateParams, $return);
  125. if (!$return) {
  126. echo $content;
  127. }
  129. $this->blockDestruct();
  130. $this->blockEnd();
  131. $this->end($return);
  133. if ($return) {
  134. return $content;
  135. }
  136. }
  138. /**
  139. * {@inheritdoc}
  140. */
  141. public function getIterator()
  142. {
  143. while ($this->loop()) {
  144. yield $this->getCurrentIndex();
  145. }
  146. }
  148. /**
  149. * @internal
  150. *
  151. * @return bool
  152. */
  153. public function loop()
  154. {
  155. $disabled = false;
  156. $config = $this->getConfig();
  157. $manual = (($config['manual'] ?? false) == true);
  159. if ($this->current > 0) {
  160. if (!$manual && $this->blockStarted) {
  161. $this->blockDestruct();
  162. $this->blockEnd();
  163. }
  164. } else {
  165. if (!$manual) {
  166. $this->start();
  167. }
  168. }
  170. if ($this->current < count($this->indices) && $this->current < $config['limit']) {
  171. $index = current($this->indices);
  172. next($this->indices);
  174. $this->currentIndex = $index;
  175. if (!empty($config['allowed']) && !in_array($index['type'], $config['allowed'])) {
  176. $disabled = true;
  177. }
  179. $brickTypeLimit = $config['limits'][$this->currentIndex['type']] ?? 100000;
  180. $brickTypeUsageCounter = $this->brickTypeUsageCounter[$this->currentIndex['type']] ?? 0;
  181. if ($brickTypeUsageCounter >= $brickTypeLimit) {
  182. $disabled = true;
  183. }
  185. if (!$this->getEditableHandler()->isBrickEnabled($this, $index['type']) && ($config['dontCheckEnabled'] ?? false) !== true) {
  186. $disabled = true;
  187. }
  189. $this->blockStarted = false;
  190. $info = $this->buildInfoObject();
  192. if (!$manual && !$disabled) {
  193. $this->blockConstruct();
  194. $templateParams = $this->blockStart($info);
  196. $this->content($info, $templateParams);
  197. } elseif (!$manual) {
  198. $this->current++;
  199. }
  201. return true;
  202. } else {
  203. if (!$manual) {
  204. $this->end();
  205. }
  207. return false;
  208. }
  209. }
  211. /**
  212. * @internal
  213. *
  214. * @return Area\Info
  215. */
  216. public function buildInfoObject(): Area\Info
  217. {
  218. $config = $this->getConfig();
  219. // create info object and assign it to the view
  220. $info = new Area\Info();
  221. $info->setId($this->currentIndex ? $this->currentIndex['type'] : null);
  222. $info->setEditable($this);
  223. $info->setIndex($this->current);
  225. $params = [];
  226. if (is_array($config['params'][$this->currentIndex['type']] ?? null)) {
  227. $params = $config['params'][$this->currentIndex['type']];
  228. }
  230. if (is_array($config['globalParams'] ?? null)) {
  231. $params = array_merge($config['globalParams'], $params);
  232. }
  234. $info->setParams($params);
  236. return $info;
  237. }
  239. /**
  240. * @param null|Document\Editable\Area\Info $info
  241. * @param array $templateParams
  242. * @param bool $return
  243. *
  244. * @return string|void
  245. */
  246. public function content($info = null, $templateParams = [], $return = false)
  247. {
  248. if (!$info) {
  249. $info = $this->buildInfoObject();
  250. }
  252. $content = '';
  254. if ($this->editmode || !isset($this->currentIndex['hidden']) || !$this->currentIndex['hidden']) {
  255. $templateParams['isAreaBlock'] = true;
  256. $content = $this->getEditableHandler()->renderAreaFrontend($info, $templateParams);
  257. if (!$return) {
  258. echo $content;
  259. }
  260. $this->brickTypeUsageCounter += [$this->currentIndex['type'] => 0];
  261. $this->brickTypeUsageCounter[$this->currentIndex['type']]++;
  262. }
  264. $this->current++;
  266. if ($return) {
  267. return $content;
  268. }
  269. }
  271. /**
  272. * @internal
  273. *
  274. * @return EditableHandler
  275. */
  276. protected function getEditableHandler()
  277. {
  278. // TODO inject area handler via DI when editables are built through container
  279. return \Pimcore::getContainer()->get(EditableHandler::class);
  280. }
  282. /**
  283. * {@inheritdoc}
  284. */
  285. public function setDataFromResource($data)
  286. {
  287. $this->indices = Tool\Serialize::unserialize($data);
  288. if (!is_array($this->indices)) {
  289. $this->indices = [];
  290. }
  292. return $this;
  293. }
  295. /**
  296. * {@inheritdoc}
  297. */
  298. public function setDataFromEditmode($data)
  299. {
  300. $this->indices = $data;
  302. return $this;
  303. }
  305. /**
  306. * {@inheritdoc}
  307. */
  308. public function blockConstruct()
  309. {
  310. // set the current block suffix for the child elements (0, 1, 3, ...)
  311. // this will be removed in blockDestruct
  312. $this->getBlockState()->pushIndex($this->indices[$this->current]['key']);
  313. }
  315. /**
  316. * {@inheritdoc}
  317. */
  318. public function blockDestruct()
  319. {
  320. $this->getBlockState()->popIndex();
  321. }
  323. /**
  324. * @return array
  325. */
  326. private function getToolBarDefaultConfig()
  327. {
  328. return [
  329. 'areablock_toolbar' => [
  330. 'width' => 172,
  331. 'buttonWidth' => 168,
  332. 'buttonMaxCharacters' => 20,
  333. ],
  334. ];
  335. }
  337. /**
  338. * {@inheritdoc}
  339. */
  340. public function getEditmodeDefinition(): array
  341. {
  342. $config = array_merge($this->getToolBarDefaultConfig(), $this->getConfig());
  344. $options = parent::getEditmodeDefinition();
  345. $options = array_merge($options, [
  346. 'config' => $config,
  347. ]);
  349. return $options;
  350. }
  352. /**
  353. * {@inheritdoc}
  354. */
  355. protected function getEditmodeElementAttributes(): array
  356. {
  357. $attributes = parent::getEditmodeElementAttributes();
  359. $attributes = array_merge($attributes, [
  360. 'name' => $this->getName(),
  361. 'type' => $this->getType(),
  362. ]);
  364. return $attributes;
  365. }
  367. /**
  368. * @param bool $return
  369. */
  370. public function start($return = false)
  371. {
  372. if (($this->config['manual'] ?? false) === true) {
  373. // in manual mode $this->render() is not called for the areablock, so we need to add
  374. // the editable to the collector manually here
  375. if ($editableDefCollector = $this->getEditableDefinitionCollector()) {
  376. $editableDefCollector->add($this);
  377. }
  378. }
  380. reset($this->indices);
  382. // set name suffix for the whole block element, this will be added to all child elements of the block
  383. $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  385. $attributes = $this->getEditmodeElementAttributes();
  386. $attributeString = HtmlUtils::assembleAttributeString($attributes);
  388. $html = '<div ' . $attributeString . '>';
  390. if ($return) {
  391. return $html;
  392. } else {
  393. $this->outputEditmode($html);
  394. }
  396. return $this;
  397. }
  399. /**
  400. * @param bool $return
  401. */
  402. public function end($return = false)
  403. {
  404. $this->current = 0;
  406. // remove the current block which was set by $this->start()
  407. $this->getBlockState()->popBlock();
  409. $html = '</div>';
  411. if ($return) {
  412. return $html;
  413. } else {
  414. $this->outputEditmode($html);
  415. }
  416. }
  418. /**
  419. * @param Document\Editable\Area\Info $info
  420. */
  421. public function blockStart($info = null)
  422. {
  423. $this->blockStarted = true;
  424. $attributes = [
  425. 'data-name' => $this->getName(),
  426. 'data-real-name' => $this->getRealName(),
  427. ];
  429. $hidden = 'false';
  430. if (isset($this->indices[$this->current]['hidden']) && $this->indices[$this->current]['hidden']) {
  431. $hidden = 'true';
  432. }
  434. $outerAttributes = [
  435. 'key' => $this->indices[$this->current]['key'],
  436. 'type' => $this->indices[$this->current]['type'],
  437. 'data-hidden' => $hidden,
  438. ];
  440. $areabrickManager = \Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  442. $dialogConfig = null;
  443. $brick = $areabrickManager->getBrick($this->indices[$this->current]['type']);
  444. if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  445. $dialogConfig = $brick->getEditableDialogBoxConfiguration($this, $info);
  446. if ($dialogConfig->getItems()) {
  447. $dialogConfig->setId('dialogBox-' . $this->getName() . '-' . $this->indices[$this->current]['key']);
  448. } else {
  449. $dialogConfig = null;
  450. }
  451. }
  453. $attr = HtmlUtils::assembleAttributeString($attributes);
  454. $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  456. $dialogAttributes = '';
  457. if ($dialogConfig) {
  458. $dialogAttributes = HtmlUtils::assembleAttributeString([
  459. 'data-dialog-id' => $dialogConfig->getId(),
  460. ]);
  461. }
  463. $dialogHtml = '';
  464. if ($dialogConfig) {
  465. $editableRenderer = \Pimcore::getContainer()->get(EditableRenderer::class);
  466. $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer, $dialogConfig->getId(), $dialogHtml);
  467. }
  469. return [
  470. 'editmodeOuterAttributes' => $oAttr,
  471. 'editmodeGenericAttributes' => $attr,
  472. 'editableDialog' => $dialogConfig,
  473. 'editableDialogAttributes' => $dialogAttributes,
  474. 'dialogHtml' => $dialogHtml,
  475. ];
  476. }
  478. /**
  479. * This method needs to be `protected` as it is used in other bundles such as pimcore/headless-documents
  480. *
  481. * @param array $config
  482. * @param EditableRenderer $editableRenderer
  483. * @param string $dialogId
  484. * @param string $html
  485. *
  486. * @throws \Exception
  487. *
  488. * @internal
  489. */
  490. protected function renderDialogBoxEditables(array $config, EditableRenderer $editableRenderer, string $dialogId, string &$html)
  491. {
  492. if (isset($config['items']) && is_array($config['items'])) {
  493. // layout component
  494. foreach ($config['items'] as $child) {
  495. $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  496. }
  497. } elseif (isset($config['name']) && isset($config['type'])) {
  498. $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  499. if (!$editable instanceof Document\Editable) {
  500. throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  501. }
  503. $editable->setInDialogBox($dialogId);
  504. $editable->addConfig('dialogBoxConfig', $config);
  505. $html .= $editable->render();
  506. } elseif (is_array($config) && isset($config[0])) {
  507. foreach ($config as $item) {
  508. $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  509. }
  510. }
  511. }
  513. /**
  514. * {@inheritdoc}
  515. */
  516. public function blockEnd()
  517. {
  518. $this->blockStarted = false;
  519. }
  521. /**
  522. * {@inheritdoc}
  523. */
  524. public function setConfig($config)
  525. {
  526. // we need to set this here otherwise custom areaDir's won't work
  527. $this->config = $config;
  529. if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  530. $config['allowed'] = [];
  531. }
  533. $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  534. $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  536. $config['types'] = $availableAreas;
  538. if (isset($config['group']) && is_array($config['group'])) {
  539. $groupingareas = [];
  540. foreach ($availableAreas as $area) {
  541. $groupingareas[$area['type']] = $area['type'];
  542. }
  544. $groups = [];
  545. foreach ($config['group'] as $name => $areas) {
  546. $n = $name;
  547. $groups[$n] = $areas;
  549. foreach ($areas as $area) {
  550. unset($groupingareas[$area]);
  551. }
  552. }
  554. if (count($groupingareas) > 0) {
  555. $uncatAreas = [];
  556. foreach ($groupingareas as $area) {
  557. $uncatAreas[] = $area;
  558. }
  559. $n = 'Uncategorized';
  560. $groups[$n] = $uncatAreas;
  561. }
  563. $config['group'] = $groups;
  564. }
  566. if (empty($config['limit'])) {
  567. $config['limit'] = 1000000;
  568. }
  570. $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  572. $this->config = $config;
  574. if (($this->config['manual'] ?? false) === true) {
  575. $this->config['reload'] = true;
  576. }
  578. return $this;
  579. }
  581. /**
  582. * Sorts areas by index (sorting option) first, then by name
  583. *
  584. * @param array $areas
  585. * @param array $config
  586. *
  587. * @return array
  588. */
  589. private function sortAvailableAreas(array $areas, array $config)
  590. {
  591. if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  592. $sorting = $config['sorting'];
  593. } else {
  594. if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  595. $sorting = $config['allowed'];
  596. } else {
  597. $sorting = [];
  598. }
  599. }
  601. $result = [
  602. 'name' => [],
  603. 'index' => [],
  604. ];
  606. foreach ($areas as $area) {
  607. $sortIndex = false;
  608. if (!empty($sorting)) {
  609. $sortIndex = array_search($area['type'], $sorting);
  610. }
  612. $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  613. if (false !== $sortIndex) {
  614. $sortKey = 'index';
  615. $area['sortIndex'] = $sortIndex;
  616. }
  618. $result[$sortKey][] = $area;
  619. }
  621. // sort with translated names
  622. if (count($result['name'])) {
  623. usort($result['name'], function ($a, $b) {
  624. if ($a['name'] == $b['name']) {
  625. return 0;
  626. }
  628. return ($a['name'] < $b['name']) ? -1 : 1;
  629. });
  630. }
  632. // sort by allowed brick config order
  633. if (count($result['index'])) {
  634. usort($result['index'], function ($a, $b) {
  635. return $a['sortIndex'] - $b['sortIndex'];
  636. });
  637. }
  639. $result = array_merge($result['index'], $result['name']);
  641. return $result;
  642. }
  644. /**
  645. * {@inheritdoc}
  646. */
  647. public function getCount()
  648. {
  649. return count($this->indices);
  650. }
  652. /**
  653. * {@inheritdoc}
  654. */
  655. public function getCurrent()
  656. {
  657. return $this->current - 1;
  658. }
  660. /**
  661. * {@inheritdoc}
  662. */
  663. public function getCurrentIndex()
  664. {
  665. return $this->indices[$this->getCurrent()]['key'] ?? null;
  666. }
  668. /**
  669. * @return array
  670. */
  671. public function getIndices()
  672. {
  673. return $this->indices;
  674. }
  676. /**
  677. * If object was serialized, set the counter back to 0
  678. */
  679. public function __wakeup()
  680. {
  681. $this->current = 0;
  682. reset($this->indices);
  683. }
  685. /**
  686. * {@inheritdoc}
  687. */
  688. public function isEmpty()
  689. {
  690. return !(bool) count($this->indices);
  691. }
  693. /**
  694. * @param string $name
  695. *
  696. * @return Areablock\Item[]
  697. */
  698. public function getElement(string $name)
  699. {
  700. $document = $this->getDocument();
  702. $parentBlockNames = $this->getParentBlockNames();
  703. $parentBlockNames[] = $this->getName();
  705. $list = [];
  706. foreach ($this->getData() as $index => $item) {
  707. if ($item['type'] === $name) {
  708. $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  709. }
  710. }
  712. return $list;
  713. }
  714. }