vendor/pimcore/pimcore/models/Document/Editable/Block.php line 25

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\Model;
  20. use Pimcore\Tool\HtmlUtils;
  22. /**
  23. * @method \Pimcore\Model\Document\Editable\Dao getDao()
  24. */
  25. class Block extends Model\Document\Editable implements BlockInterface
  26. {
  27. /**
  28. * @internal
  29. */
  30. const ATTRIBUTE_IGNORE_EDITMODE_INDICES = '_block_ignore_extra_editmode_indices';
  32. /**
  33. * Contains an array of indices, which represent the order of the elements in the block
  34. *
  35. * @internal
  36. *
  37. * @var array
  38. */
  39. protected $indices = [];
  41. /**
  42. * Current step of the block while iteration
  43. *
  44. * @internal
  45. *
  46. * @var int
  47. */
  48. protected $current = 0;
  50. /**
  51. * {@inheritdoc}
  52. */
  53. public function getType()
  54. {
  55. return 'block';
  56. }
  58. /**
  59. * {@inheritdoc}
  60. */
  61. public function getData()
  62. {
  63. return $this->indices;
  64. }
  66. /**
  67. * {@inheritdoc}
  68. */
  69. public function admin()
  70. {
  71. // nothing to do
  72. return '';
  73. }
  75. /**
  76. * {@inheritdoc}
  77. */
  78. public function frontend()
  79. {
  80. // nothing to do
  81. return '';
  82. }
  84. /**
  85. * {@inheritdoc}
  86. */
  87. public function setDataFromResource($data)
  88. {
  89. $this->indices = \Pimcore\Tool\Serialize::unserialize($data);
  91. return $this;
  92. }
  94. /**
  95. * {@inheritdoc}
  96. */
  97. public function setDataFromEditmode($data)
  98. {
  99. $this->indices = $data;
  101. return $this;
  102. }
  104. /**
  105. * @internal
  106. *
  107. * @return $this
  108. */
  109. protected function setDefault()
  110. {
  111. if (empty($this->indices) && isset($this->config['default']) && $this->config['default']) {
  112. for ($i = 0; $i < (int)$this->config['default']; $i++) {
  113. $this->indices[$i] = $i + 1;
  114. }
  115. }
  117. return $this;
  118. }
  120. /**
  121. * {@inheritdoc}
  122. */
  123. public function getIterator()
  124. {
  125. while ($this->loop()) {
  126. yield $this->getCurrentIndex();
  127. }
  129. if ($this->getEditmode() && !$this->isIgnoreEditmodeIndices()) {
  130. // yeah, I know the following is f******* crazy :D
  131. $this->current = 0;
  132. $indicesBackup = $this->indices;
  133. $this->indices[0] = 1000000;
  134. $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  135. $this->blockConstruct();
  136. $blockStartHtml = $this->blockStart(true, true);
  137. ob_start();
  139. $editableDefCollector = $this->getEditableDefinitionCollector();
  140. $editableDefCollector->stashPush();
  142. yield $this->getCurrentIndex() + 1;
  144. $blockEndHtml = $this->blockEnd(true);
  145. $this->blockDestruct();
  146. $blockState = $this->getBlockState();
  147. if ($blockState->hasBlocks()) {
  148. $blockState->popBlock();
  149. }
  151. $templateEditableDefinitions = $editableDefCollector->getDefinitions();
  152. $editableDefCollector->stashPull();
  154. $this->config['template'] = [
  155. 'html' => $blockStartHtml . ob_get_clean() . $blockEndHtml,
  156. 'editables' => $templateEditableDefinitions,
  157. ];
  159. $editableDefCollector->add($this);
  161. $this->indices = $indicesBackup;
  162. }
  163. }
  165. /**
  166. * @internal
  167. *
  168. * @return bool
  169. */
  170. public function loop()
  171. {
  172. $manual = false;
  173. if (($this->config['manual'] ?? false) == true) {
  174. $manual = true;
  175. }
  177. $this->setDefault();
  179. if ($this->current > 0) {
  180. if (!$manual) {
  181. $this->blockDestruct();
  182. $this->blockEnd();
  183. }
  184. } else {
  185. if (!$manual) {
  186. $this->start();
  187. }
  188. }
  190. if ($this->current < count($this->indices) && $this->current < $this->config['limit']) {
  191. if (!$manual) {
  192. $this->blockConstruct();
  193. $this->blockStart();
  194. }
  196. return true;
  197. } else {
  198. if (!$manual) {
  199. $this->end();
  200. }
  202. return false;
  203. }
  204. }
  206. /**
  207. * {@inheritdoc}
  208. */
  209. protected function getEditmodeElementAttributes(): array
  210. {
  211. $attributes = parent::getEditmodeElementAttributes();
  213. $attributes = array_merge($attributes, [
  214. 'name' => $this->getName(),
  215. 'type' => $this->getType(),
  216. ]);
  218. return $attributes;
  219. }
  221. /**
  222. * {@inheritdoc}
  223. */
  224. public function start()
  225. {
  226. // set name suffix for the whole block element, this will be added to all child elements of the block
  227. $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  229. $attributes = $this->getEditmodeElementAttributes();
  230. $attributeString = HtmlUtils::assembleAttributeString($attributes);
  232. $this->outputEditmode('<div ' . $attributeString . '>');
  234. return $this;
  235. }
  237. /**
  238. * {@inheritdoc}
  239. */
  240. public function end()
  241. {
  242. $this->current = 0;
  244. // remove the current block which was set by $this->start()
  245. $blockState = $this->getBlockState();
  246. if ($blockState->hasBlocks()) {
  247. $blockState->popBlock();
  248. }
  250. $this->outputEditmode('</div>');
  251. }
  253. /**
  254. * {@inheritdoc}
  255. */
  256. public function blockConstruct()
  257. {
  258. // set the current block suffix for the child elements (0, 1, 3, ...)
  259. // this will be removed in blockDestruct
  260. $this->getBlockState()->pushIndex($this->indices[$this->current] ?? 0);
  261. }
  263. /**
  264. * {@inheritdoc}
  265. */
  266. public function blockDestruct()
  267. {
  268. $blockState = $this->getBlockState();
  269. if ($blockState->hasIndexes()) {
  270. $blockState->popIndex();
  271. }
  272. }
  274. /**
  275. * {@inheritdoc}
  276. */
  277. public function blockStart($showControls = true, $return = false, $additionalClass = '')
  278. {
  279. $attr = $this->getBlockAttributes();
  281. $outerAttributes = [
  282. 'key' => $this->indices[$this->current] ?? null,
  283. ];
  284. $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  286. $class = 'pimcore_block_entry';
  287. if (!empty($additionalClass)) {
  288. $class = sprintf('%s %s', $class, $additionalClass);
  289. }
  291. $html = '<div class="' . $class . '" ' . $oAttr . ' ' . $attr . '>';
  293. if ($showControls) {
  294. $html .= $this->blockControls(true);
  295. }
  297. if ($return) {
  298. return $html;
  299. }
  301. $this->outputEditmode($html);
  302. }
  304. /**
  305. * Custom position of button controls between blockStart -> blockEnd
  306. *
  307. * @param bool $return
  308. */
  309. public function blockControls($return = false)
  310. {
  311. $attr = $this->getBlockAttributes();
  313. $html = <<<EOT
  314. <div class="pimcore_block_buttons" $attr>
  315. <div class="pimcore_block_amount" $attr></div>
  316. <div class="pimcore_block_plus" $attr></div>
  317. <div class="pimcore_block_minus" $attr></div>
  318. <div class="pimcore_block_up" $attr></div>
  319. <div class="pimcore_block_down" $attr></div>
  320. <div class="pimcore_block_clear" $attr></div>
  321. </div>
  322. EOT;
  324. $this->current++;
  326. if ($return) {
  327. return $html;
  328. }
  330. $this->outputEditmode($html);
  331. }
  333. /**
  334. * {@inheritdoc}
  335. */
  336. public function blockEnd($return = false)
  337. {
  338. // close outer element
  339. $html = '</div>';
  341. if ($return) {
  342. return $html;
  343. }
  345. $this->outputEditmode($html);
  346. }
  348. /**
  349. * {@inheritdoc}
  350. */
  351. public function setConfig($config)
  352. {
  353. if (empty($config['limit'])) {
  354. $config['limit'] = 1000000;
  355. }
  357. $this->config = $config;
  359. if (($this->config['manual'] ?? false) === true) {
  360. $this->config['reload'] = true;
  361. }
  363. return $this;
  364. }
  366. /**
  367. * {@inheritdoc}
  368. */
  369. public function getCount()
  370. {
  371. return count($this->indices);
  372. }
  374. /**
  375. * {@inheritdoc}
  376. */
  377. public function getCurrent()
  378. {
  379. return $this->current - 1;
  380. }
  382. /**
  383. * {@inheritdoc}
  384. */
  385. public function getCurrentIndex()
  386. {
  387. return $this->indices[$this->getCurrent()] ?? 0;
  388. }
  390. /**
  391. * @return array
  392. */
  393. public function getIndices()
  394. {
  395. return $this->indices;
  396. }
  398. /**
  399. * If object was serialized, set the counter back to 0
  400. */
  401. public function __wakeup()
  402. {
  403. $this->current = 0;
  404. }
  406. /**
  407. * {@inheritdoc}
  408. */
  409. public function isEmpty()
  410. {
  411. return !(bool) count($this->indices);
  412. }
  414. /**
  415. * @return Block\Item[]
  416. */
  417. public function getElements()
  418. {
  419. $document = $this->getDocument();
  421. // https://github.com/pimcore/pimcore/issues/6629
  422. if (!$document instanceof Model\Document\PageSnippet) {
  423. return [];
  424. }
  426. $parentBlockNames = $this->getParentBlockNames();
  427. $parentBlockNames[] = $this->getName();
  429. $list = [];
  430. foreach ($this->getData() as $index) {
  431. $list[] = new Block\Item($document, $parentBlockNames, (int)$index);
  432. }
  434. return $list;
  435. }
  437. /**
  438. * @return string
  439. */
  440. private function getBlockAttributes(): string
  441. {
  442. $attributes = [
  443. 'data-name' => $this->getName(),
  444. 'data-real-name' => $this->getRealName(),
  445. ];
  447. return HtmlUtils::assembleAttributeString($attributes);
  448. }
  450. /**
  451. * @return bool
  452. */
  453. private function isIgnoreEditmodeIndices(): bool
  454. {
  455. $requestStack = \Pimcore::getContainer()->get('request_stack');
  456. $request = $requestStack->getCurrentRequest();
  457. if ($request === null) {
  458. return false;
  459. }
  461. return $request->get(self::ATTRIBUTE_IGNORE_EDITMODE_INDICES, false);
  462. }
  463. }