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()) {
  131.             // yeah, I know the following is f******* crazy :D
  132.             $this->current = 0;
  133.             $indicesBackup = $this->indices;
  134.             $this->indices[0] = 1000000;
  135.             $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  136.             $this->blockConstruct();
  137.             $blockStartHtml = $this->blockStart(true, true);
  138.             ob_start();
  140.             $editableDefCollector = $this->getEditableDefinitionCollector();
  141.             $editableDefCollector->stashPush();
  143.             yield $this->getCurrentIndex() + 1;
  145.             $blockEndHtml = $this->blockEnd(true);
  146.             $this->blockDestruct();
  147.             $blockState = $this->getBlockState();
  148.             if ($blockState->hasBlocks()) {
  149.                 $blockState->popBlock();
  150.             }
  152.             $templateEditableDefinitions = $editableDefCollector->getDefinitions();
  153.             $editableDefCollector->stashPull();
  155.             $this->config['template'] = [
  156.                 'html' => $blockStartHtml . ob_get_clean() . $blockEndHtml,
  157.                 'editables' => $templateEditableDefinitions,
  158.             ];
  160.             $editableDefCollector->add($this);
  162.             $this->indices = $indicesBackup;
  163.         }
  164.     }
  166.     /**
  167.      * @internal
  168.      *
  169.      * @return bool
  170.      */
  171.     public function loop()
  172.     {
  173.         $manual = false;
  174.         if (($this->config['manual'] ?? false) == true) {
  175.             $manual = true;
  176.         }
  178.         $this->setDefault();
  180.         if ($this->current > 0) {
  181.             if (!$manual) {
  182.                 $this->blockDestruct();
  183.                 $this->blockEnd();
  184.             }
  185.         } else {
  186.             if (!$manual) {
  187.                 $this->start();
  188.             }
  189.         }
  191.         if ($this->current < count($this->indices) && $this->current < $this->config['limit']) {
  192.             if (!$manual) {
  193.                 $this->blockConstruct();
  194.                 $this->blockStart();
  195.             }
  197.             return true;
  198.         } else {
  199.             if (!$manual) {
  200.                 $this->end();
  201.             }
  203.             return false;
  204.         }
  205.     }
  207.     /**
  208.      * {@inheritdoc}
  209.      */
  210.     protected function getEditmodeElementAttributes(): array
  211.     {
  212.         $attributes = parent::getEditmodeElementAttributes();
  214.         $attributes = array_merge($attributes, [
  215.             'name' => $this->getName(),
  216.             'type' => $this->getType(),
  217.         ]);
  219.         return $attributes;
  220.     }
  222.     /**
  223.      * {@inheritdoc}
  224.      */
  225.     public function start()
  226.     {
  227.         // set name suffix for the whole block element, this will be added to all child elements of the block
  228.         $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  230.         $attributes = $this->getEditmodeElementAttributes();
  231.         $attributeString = HtmlUtils::assembleAttributeString($attributes);
  233.         $this->outputEditmode('<div ' . $attributeString . '>');
  235.         return $this;
  236.     }
  238.     /**
  239.      * {@inheritdoc}
  240.      */
  241.     public function end()
  242.     {
  243.         $this->current = 0;
  245.         // remove the current block which was set by $this->start()
  246.         $blockState = $this->getBlockState();
  247.         if ($blockState->hasBlocks()) {
  248.             $blockState->popBlock();
  249.         }
  251.         $this->outputEditmode('</div>');
  252.     }
  254.     /**
  255.      * {@inheritdoc}
  256.      */
  257.     public function blockConstruct()
  258.     {
  259.         // set the current block suffix for the child elements (0, 1, 3, ...)
  260.         // this will be removed in blockDestruct
  261.         $this->getBlockState()->pushIndex($this->indices[$this->current] ?? 0);
  262.     }
  264.     /**
  265.      * {@inheritdoc}
  266.      */
  267.     public function blockDestruct()
  268.     {
  269.         $blockState = $this->getBlockState();
  270.         if ($blockState->hasIndexes()) {
  271.             $blockState->popIndex();
  272.         }
  273.     }
  275.     /**
  276.      * {@inheritdoc}
  277.      */
  278.     public function blockStart($showControls = true, $return = false)
  279.     {
  280.         $attr = $this->getBlockAttributes();
  282.         $outerAttributes = [
  283.             'key' => $this->indices[$this->current] ?? null,
  284.         ];
  285.         $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  287.         $html = '<div class="pimcore_block_entry" ' . $oAttr . ' ' . $attr . '>';
  289.         if ($showControls) {
  290.             $html .= $this->blockControls(true);
  291.         }
  293.         if ($return) {
  294.             return $html;
  295.         }
  297.         $this->outputEditmode($html);
  298.     }
  300.     /**
  301.      * Custom position of button controls between blockStart -> blockEnd
  302.      *
  303.      * @param bool $return
  304.      */
  305.     public function blockControls($return = false)
  306.     {
  307.         $attr = $this->getBlockAttributes();
  309.         $html = <<<EOT
  310. <div class="pimcore_block_buttons" $attr>
  311.     <div class="pimcore_block_amount" $attr></div>
  312.     <div class="pimcore_block_plus" $attr></div>
  313.     <div class="pimcore_block_minus" $attr></div>
  314.     <div class="pimcore_block_up" $attr></div>
  315.     <div class="pimcore_block_down" $attr></div>
  316.     <div class="pimcore_block_clear" $attr></div>
  317. </div>
  318. EOT;
  320.         $this->current++;
  322.         if ($return) {
  323.             return $html;
  324.         }
  326.         $this->outputEditmode($html);
  327.     }
  329.     /**
  330.      * {@inheritdoc}
  331.      */
  332.     public function blockEnd($return = false)
  333.     {
  334.         // close outer element
  335.         $html = '</div>';
  337.         if ($return) {
  338.             return $html;
  339.         }
  341.         $this->outputEditmode($html);
  342.     }
  344.     /**
  345.      * {@inheritdoc}
  346.      */
  347.     public function setConfig($config)
  348.     {
  349.         if (empty($config['limit'])) {
  350.             $config['limit'] = 1000000;
  351.         }
  353.         $this->config = $config;
  355.         if (($this->config['manual'] ?? false) === true) {
  356.             $this->config['reload'] = true;
  357.         }
  359.         return $this;
  360.     }
  362.     /**
  363.      * {@inheritdoc}
  364.      */
  365.     public function getCount()
  366.     {
  367.         return count($this->indices);
  368.     }
  370.     /**
  371.      * {@inheritdoc}
  372.      */
  373.     public function getCurrent()
  374.     {
  375.         return $this->current - 1;
  376.     }
  378.     /**
  379.      * {@inheritdoc}
  380.      */
  381.     public function getCurrentIndex()
  382.     {
  383.         return $this->indices[$this->getCurrent()] ?? 0;
  384.     }
  386.     /**
  387.      * @return array
  388.      */
  389.     public function getIndices()
  390.     {
  391.         return $this->indices;
  392.     }
  394.     /**
  395.      * If object was serialized, set the counter back to 0
  396.      */
  397.     public function __wakeup()
  398.     {
  399.         $this->current = 0;
  400.     }
  402.     /**
  403.      * {@inheritdoc}
  404.      */
  405.     public function isEmpty()
  406.     {
  407.         return !(bool) count($this->indices);
  408.     }
  410.     /**
  411.      * @return Block\Item[]
  412.      */
  413.     public function getElements()
  414.     {
  415.         $document = $this->getDocument();
  417.         // https://github.com/pimcore/pimcore/issues/6629
  418.         if (!$document instanceof Model\Document\PageSnippet) {
  419.             return [];
  420.         }
  422.         $parentBlockNames = $this->getParentBlockNames();
  423.         $parentBlockNames[] = $this->getName();
  425.         $list = [];
  426.         foreach ($this->getData() as $index) {
  427.             $list[] = new Block\Item($document, $parentBlockNames, (int)$index);
  428.         }
  430.         return $list;
  431.     }
  433.     /**
  434.      * @return string
  435.      */
  436.     private function getBlockAttributes(): string
  437.     {
  438.         $attributes = [
  439.             'data-name' => $this->getName(),
  440.             'data-real-name' => $this->getRealName(),
  441.         ];
  443.         return HtmlUtils::assembleAttributeString($attributes);
  444.     }
  446.     /**
  447.      * @return bool
  448.      */
  449.     private function isIgnoreEditmodeIndices(): bool
  450.     {
  451.         $requestStack = \Pimcore::getContainer()->get('request_stack');
  452.         $request = $requestStack->getCurrentRequest();
  453.         if ($request === null) {
  454.             return false;
  455.         }
  457.         return $request->get(self::ATTRIBUTE_IGNORE_EDITMODE_INDICES, false);
  458.     }
  459. }