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. }