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

  1. <?php
  2. declare(strict_types=1);
  4. /**
  5.  * Pimcore
  6.  *
  7.  * This source file is available under two different licenses:
  8.  * - GNU General Public License version 3 (GPLv3)
  9.  * - Pimcore Commercial License (PCL)
  10.  * Full copyright and license information is available in
  11.  * LICENSE.md which is distributed with this source code.
  12.  *
  13.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  14.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  15.  */
  17. namespace Pimcore\Model\Document\Editable;
  19. use Pimcore\Document\Editable\Block\BlockName;
  20. use Pimcore\Model;
  21. use Pimcore\Tool\HtmlUtils;
  23. /**
  24.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  25.  */
  26. class Block extends Model\Document\Editable implements BlockInterface
  27. {
  28.     /**
  29.      * @internal
  30.      */
  31.     const ATTRIBUTE_IGNORE_EDITMODE_INDICES = '_block_ignore_extra_editmode_indices';
  33.     /**
  34.      * Contains an array of indices, which represent the order of the elements in the block
  35.      *
  36.      * @internal
  37.      *
  38.      */
  39.     protected array $indices = [];
  41.     /**
  42.      * Current step of the block while iteration
  43.      *
  44.      * @internal
  45.      *
  46.      */
  47.     protected int $current = 0;
  49.     public function getType(): string
  50.     {
  51.         return 'block';
  52.     }
  54.     public function getData(): mixed
  55.     {
  56.         return $this->indices;
  57.     }
  59.     public function admin()
  60.     {
  61.         // nothing to do
  62.         return '';
  63.     }
  65.     public function frontend()
  66.     {
  67.         // nothing to do
  68.         return '';
  69.     }
  71.     public function setDataFromResource(mixed $data): static
  72.     {
  73.         $this->indices = \Pimcore\Tool\Serialize::unserialize($data);
  75.         return $this;
  76.     }
  78.     public function setDataFromEditmode(mixed $data): static
  79.     {
  80.         $this->indices = $data;
  82.         return $this;
  83.     }
  85.     /**
  86.      * @internal
  87.      *
  88.      * @return $this
  89.      */
  90.     protected function setDefault(): static
  91.     {
  92.         if (empty($this->indices) && isset($this->config['default']) && $this->config['default']) {
  93.             for ($i = 0; $i < (int)$this->config['default']; $i++) {
  94.                 $this->indices[$i] = $i + 1;
  95.             }
  96.         }
  98.         return $this;
  99.     }
  101.     public function getIterator(): \Generator
  102.     {
  103.         while ($this->loop()) {
  104.             yield $this->getCurrentIndex();
  105.         }
  107.         if ($this->getEditmode() && !$this->isIgnoreEditmodeIndices()) {
  108.             // yeah, I know the following is f******* crazy :D
  109.             $this->current = 0;
  110.             $indicesBackup = $this->indices;
  111.             $this->indices[0] = 1000000;
  112.             $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  113.             $this->blockConstruct();
  114.             $blockStartHtml = $this->blockStart(true, true);
  115.             ob_start();
  117.             $editableDefCollector = $this->getEditableDefinitionCollector();
  118.             $editableDefCollector->stashPush();
  120.             yield $this->getCurrentIndex() + 1;
  122.             $blockEndHtml = $this->blockEnd(true);
  123.             $this->blockDestruct();
  124.             $blockState = $this->getBlockState();
  125.             if ($blockState->hasBlocks()) {
  126.                 $blockState->popBlock();
  127.             }
  129.             $templateEditableDefinitions = $editableDefCollector->getDefinitions();
  130.             $editableDefCollector->stashPull();
  132.             $this->config['template'] = [
  133.                 'html' => $blockStartHtml . ob_get_clean() . $blockEndHtml,
  134.                 'editables' => $templateEditableDefinitions,
  135.             ];
  137.             $editableDefCollector->add($this);
  139.             $this->indices = $indicesBackup;
  140.         }
  141.     }
  143.     /**
  144.      * @internal
  145.      *
  146.      */
  147.     public function loop(): bool
  148.     {
  149.         $manual = false;
  150.         if (($this->config['manual'] ?? false) == true) {
  151.             $manual = true;
  152.         }
  154.         $this->setDefault();
  156.         if ($this->current > 0) {
  157.             if (!$manual) {
  158.                 $this->blockDestruct();
  159.                 $this->blockEnd();
  160.             }
  161.         } else {
  162.             if (!$manual) {
  163.                 $this->start();
  164.             }
  165.         }
  167.         if ($this->current < count($this->indices) && $this->current < $this->config['limit']) {
  168.             if (!$manual) {
  169.                 $this->blockConstruct();
  170.                 $this->blockStart();
  171.             }
  173.             return true;
  174.         } else {
  175.             if (!$manual) {
  176.                 $this->end();
  177.             }
  179.             return false;
  180.         }
  181.     }
  183.     protected function getEditmodeElementAttributes(): array
  184.     {
  185.         $attributes = parent::getEditmodeElementAttributes();
  187.         $attributes = array_merge($attributes, [
  188.             'name' => $this->getName(),
  189.             'type' => $this->getType(),
  190.         ]);
  192.         return $attributes;
  193.     }
  195.     public function start()
  196.     {
  197.         // set name suffix for the whole block element, this will be added to all child elements of the block
  198.         $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  200.         $attributes = $this->getEditmodeElementAttributes();
  201.         $attributeString = HtmlUtils::assembleAttributeString($attributes);
  203.         $this->outputEditmode('<div ' . $attributeString . '>');
  205.         return $this;
  206.     }
  208.     public function end(bool $return = false): void
  209.     {
  210.         $this->current = 0;
  212.         // remove the current block which was set by $this->start()
  213.         $blockState = $this->getBlockState();
  214.         if ($blockState->hasBlocks()) {
  215.             $blockState->popBlock();
  216.         }
  218.         $this->outputEditmode('</div>');
  219.     }
  221.     public function blockConstruct(): void
  222.     {
  223.         // set the current block suffix for the child elements (0, 1, 3, ...)
  224.         // this will be removed in blockDestruct
  225.         $this->getBlockState()->pushIndex((int) ($this->indices[$this->current] ?? 0));
  226.     }
  228.     public function blockDestruct(): void
  229.     {
  230.         $blockState = $this->getBlockState();
  231.         if ($blockState->hasIndexes()) {
  232.             $blockState->popIndex();
  233.         }
  234.     }
  236.     public function blockStart(bool $showControls = true, bool $return = false, string $additionalClass = '')
  237.     {
  238.         $attr = $this->getBlockAttributes();
  240.         $outerAttributes = [
  241.             'key' => $this->indices[$this->current] ?? null,
  242.         ];
  243.         $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  245.         $class = 'pimcore_block_entry';
  246.         if (!empty($additionalClass)) {
  247.             $class = sprintf('%s %s', $class, $additionalClass);
  248.         }
  250.         $html = '<div class="' . $class . '" ' . $oAttr . ' ' . $attr . '>';
  252.         if ($showControls) {
  253.             $html .= $this->blockControls(true);
  254.         }
  256.         if ($return) {
  257.             return $html;
  258.         }
  260.         $this->outputEditmode($html);
  261.     }
  263.     /**
  264.      * Custom position of button controls between blockStart -> blockEnd
  265.      *
  266.      * @return ($return is true ? string : void)
  267.      */
  268.     public function blockControls(bool $return = false)
  269.     {
  270.         $attr = $this->getBlockAttributes();
  272.         $html = <<<EOT
  273. <div class="pimcore_block_buttons" $attr>
  274.     <div class="pimcore_block_amount" $attr></div>
  275.     <div class="pimcore_block_plus" $attr></div>
  276.     <div class="pimcore_block_minus" $attr></div>
  277.     <div class="pimcore_block_up" $attr></div>
  278.     <div class="pimcore_block_down" $attr></div>
  279.     <div class="pimcore_block_clear" $attr></div>
  280. </div>
  281. EOT;
  283.         $this->current++;
  285.         if ($return) {
  286.             return $html;
  287.         }
  289.         $this->outputEditmode($html);
  290.     }
  292.     public function blockEnd(bool $return = false)
  293.     {
  294.         // close outer element
  295.         $html = '</div>';
  297.         if ($return) {
  298.             return $html;
  299.         }
  301.         $this->outputEditmode($html);
  302.     }
  304.     public function setConfig(array $config): static
  305.     {
  306.         if (empty($config['limit'])) {
  307.             $config['limit'] = 1000000;
  308.         }
  310.         $this->config = $config;
  312.         if (($this->config['manual'] ?? false) === true) {
  313.             $this->config['reload'] = true;
  314.         }
  316.         return $this;
  317.     }
  319.     public function getCount(): int
  320.     {
  321.         return count($this->indices);
  322.     }
  324.     public function getCurrent(): int
  325.     {
  326.         return $this->current - 1;
  327.     }
  329.     public function getCurrentIndex(): int
  330.     {
  331.         return (int) ($this->indices[$this->getCurrent()] ?? 0);
  332.     }
  334.     public function getIndices(): array
  335.     {
  336.         return $this->indices;
  337.     }
  339.     /**
  340.      * If object was serialized, set the counter back to 0
  341.      */
  342.     public function __wakeup(): void
  343.     {
  344.         $this->current = 0;
  345.     }
  347.     public function isEmpty(): bool
  348.     {
  349.         return !(bool) count($this->indices);
  350.     }
  352.     /**
  353.      * @return Block\Item[]
  354.      */
  355.     public function getElements(): array
  356.     {
  357.         $document = $this->getDocument();
  359.         // https://github.com/pimcore/pimcore/issues/6629
  360.         if (!$document instanceof Model\Document\PageSnippet) {
  361.             return [];
  362.         }
  364.         $parentBlockNames = $this->getParentBlockNames();
  365.         $parentBlockNames[] = $this->getName();
  367.         $list = [];
  368.         foreach ($this->getData() as $index) {
  369.             $list[] = new Block\Item($document, $parentBlockNames, (int)$index);
  370.         }
  372.         return $list;
  373.     }
  375.     private function getBlockAttributes(): string
  376.     {
  377.         $attributes = [
  378.             'data-name' => $this->getName(),
  379.             'data-real-name' => $this->getRealName(),
  380.         ];
  382.         return HtmlUtils::assembleAttributeString($attributes);
  383.     }
  385.     private function isIgnoreEditmodeIndices(): bool
  386.     {
  387.         $requestStack = \Pimcore::getContainer()->get('request_stack');
  388.         $request = $requestStack->getCurrentRequest();
  389.         if ($request === null) {
  390.             return false;
  391.         }
  393.         return $request->attributes->getBoolean(self::ATTRIBUTE_IGNORE_EDITMODE_INDICES);
  394.     }
  395. }