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