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. * @param bool $showControls
  276. * @param bool $return
  277. * @param string $additionalClass
  278. */
  279. public function blockStart($showControls = true, $return = false, $additionalClass = '')
  280. {
  281. $attr = $this->getBlockAttributes();
  283. $outerAttributes = [
  284. 'key' => $this->indices[$this->current] ?? null,
  285. ];
  286. $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  288. $class = 'pimcore_block_entry';
  289. if (!empty($additionalClass)) {
  290. $class = sprintf('%s %s', $class, $additionalClass);
  291. }
  293. $html = '<div class="' . $class . '" ' . $oAttr . ' ' . $attr . '>';
  295. if ($showControls) {
  296. $html .= $this->blockControls(true);
  297. }
  299. if ($return) {
  300. return $html;
  301. }
  303. $this->outputEditmode($html);
  304. }
  306. /**
  307. * Custom position of button controls between blockStart -> blockEnd
  308. *
  309. * @param bool $return
  310. */
  311. public function blockControls($return = false)
  312. {
  313. $attr = $this->getBlockAttributes();
  315. $html = <<<EOT
  316. <div class="pimcore_block_buttons" $attr>
  317. <div class="pimcore_block_amount" $attr></div>
  318. <div class="pimcore_block_plus" $attr></div>
  319. <div class="pimcore_block_minus" $attr></div>
  320. <div class="pimcore_block_up" $attr></div>
  321. <div class="pimcore_block_down" $attr></div>
  322. <div class="pimcore_block_clear" $attr></div>
  323. </div>
  324. EOT;
  326. $this->current++;
  328. if ($return) {
  329. return $html;
  330. }
  332. $this->outputEditmode($html);
  333. }
  335. /**
  336. * @param bool $return
  337. */
  338. public function blockEnd($return = false)
  339. {
  340. // close outer element
  341. $html = '</div>';
  343. if ($return) {
  344. return $html;
  345. }
  347. $this->outputEditmode($html);
  348. }
  350. /**
  351. * {@inheritdoc}
  352. */
  353. public function setConfig($config)
  354. {
  355. if (empty($config['limit'])) {
  356. $config['limit'] = 1000000;
  357. }
  359. $this->config = $config;
  361. if (($this->config['manual'] ?? false) === true) {
  362. $this->config['reload'] = true;
  363. }
  365. return $this;
  366. }
  368. /**
  369. * {@inheritdoc}
  370. */
  371. public function getCount()
  372. {
  373. return count($this->indices);
  374. }
  376. /**
  377. * {@inheritdoc}
  378. */
  379. public function getCurrent()
  380. {
  381. return $this->current - 1;
  382. }
  384. /**
  385. * {@inheritdoc}
  386. */
  387. public function getCurrentIndex()
  388. {
  389. return $this->indices[$this->getCurrent()] ?? 0;
  390. }
  392. /**
  393. * @return array
  394. */
  395. public function getIndices()
  396. {
  397. return $this->indices;
  398. }
  400. /**
  401. * If object was serialized, set the counter back to 0
  402. */
  403. public function __wakeup()
  404. {
  405. $this->current = 0;
  406. }
  408. /**
  409. * {@inheritdoc}
  410. */
  411. public function isEmpty()
  412. {
  413. return !(bool) count($this->indices);
  414. }
  416. /**
  417. * @return Block\Item[]
  418. */
  419. public function getElements()
  420. {
  421. $document = $this->getDocument();
  423. // https://github.com/pimcore/pimcore/issues/6629
  424. if (!$document instanceof Model\Document\PageSnippet) {
  425. return [];
  426. }
  428. $parentBlockNames = $this->getParentBlockNames();
  429. $parentBlockNames[] = $this->getName();
  431. $list = [];
  432. foreach ($this->getData() as $index) {
  433. $list[] = new Block\Item($document, $parentBlockNames, (int)$index);
  434. }
  436. return $list;
  437. }
  439. /**
  440. * @return string
  441. */
  442. private function getBlockAttributes(): string
  443. {
  444. $attributes = [
  445. 'data-name' => $this->getName(),
  446. 'data-real-name' => $this->getRealName(),
  447. ];
  449. return HtmlUtils::assembleAttributeString($attributes);
  450. }
  452. /**
  453. * @return bool
  454. */
  455. private function isIgnoreEditmodeIndices(): bool
  456. {
  457. $requestStack = \Pimcore::getContainer()->get('request_stack');
  458. $request = $requestStack->getCurrentRequest();
  459. if ($request === null) {
  460. return false;
  461. }
  463. return $request->get(self::ATTRIBUTE_IGNORE_EDITMODE_INDICES, false);
  464. }
  465. }