vendor/pimcore/pimcore/models/Document/Editable/Areablock.php line 533

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\Document\Editable\EditableHandler;
  20. use Pimcore\Extension\Document\Areabrick\AreabrickManagerInterface;
  21. use Pimcore\Extension\Document\Areabrick\EditableDialogBoxInterface;
  22. use Pimcore\Model;
  23. use Pimcore\Model\Document;
  24. use Pimcore\Templating\Renderer\EditableRenderer;
  25. use Pimcore\Tool;
  26. use Pimcore\Tool\HtmlUtils;
  28. /**
  29.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  30.  */
  31. class Areablock extends Model\Document\Editable implements BlockInterface
  32. {
  33.     /**
  34.      * Contains an array of indices, which represent the order of the elements in the block
  35.      *
  36.      * @internal
  37.      *
  38.      * @var array
  39.      */
  40.     protected $indices = [];
  42.     /**
  43.      * Current step of the block while iteration
  44.      *
  45.      * @internal
  46.      *
  47.      * @var int
  48.      */
  49.     protected $current = 0;
  51.     /**
  52.      * @internal
  53.      *
  54.      * @var array|null
  55.      */
  56.     protected $currentIndex;
  58.     /**
  59.      * @internal
  60.      *
  61.      * @var bool|null
  62.      */
  63.     protected $blockStarted;
  65.     /**
  66.      * @internal
  67.      *
  68.      * @var array
  69.      */
  70.     protected $brickTypeUsageCounter = [];
  72.     /**
  73.      * {@inheritdoc}
  74.      */
  75.     public function getType()
  76.     {
  77.         return 'areablock';
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function getData()
  84.     {
  85.         return $this->indices;
  86.     }
  88.     /**
  89.      * {@inheritdoc}
  90.      */
  91.     public function admin()
  92.     {
  93.         $this->frontend();
  94.     }
  96.     /**
  97.      * {@inheritdoc}
  98.      */
  99.     public function frontend()
  100.     {
  101.         if (!is_array($this->indices)) {
  102.             $this->indices = [];
  103.         }
  104.         reset($this->indices);
  105.         while ($this->loop());
  106.     }
  108.     /**
  109.      * @internal
  110.      *
  111.      * @param int $index
  112.      * @param bool $return
  113.      */
  114.     public function renderIndex($index, $return = false)
  115.     {
  116.         $this->start($return);
  118.         $this->currentIndex = $this->indices[$index];
  119.         $this->current = $index;
  121.         $this->blockConstruct();
  122.         $templateParams = $this->blockStart();
  124.         $content = $this->content(null, $templateParams, $return);
  125.         if (!$return) {
  126.             echo $content;
  127.         }
  129.         $this->blockDestruct();
  130.         $this->blockEnd();
  131.         $this->end($return);
  133.         if ($return) {
  134.             return $content;
  135.         }
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function getIterator()
  142.     {
  143.         while ($this->loop()) {
  144.             yield $this->getCurrentIndex();
  145.         }
  146.     }
  148.     /**
  149.      * @internal
  150.      *
  151.      * @return bool
  152.      */
  153.     public function loop()
  154.     {
  155.         $disabled = false;
  156.         $config = $this->getConfig();
  157.         $manual = (($config['manual'] ?? false) == true);
  159.         if ($this->current > 0) {
  160.             if (!$manual && $this->blockStarted) {
  161.                 $this->blockDestruct();
  162.                 $this->blockEnd();
  163.             }
  164.         } else {
  165.             if (!$manual) {
  166.                 $this->start();
  167.             }
  168.         }
  170.         if ($this->current < count($this->indices) && $this->current < $config['limit']) {
  171.             $index = current($this->indices);
  172.             next($this->indices);
  174.             $this->currentIndex = $index;
  175.             if (!empty($config['allowed']) && !in_array($index['type'], $config['allowed'])) {
  176.                 $disabled = true;
  177.             }
  179.             $brickTypeLimit = $config['limits'][$this->currentIndex['type']] ?? 100000;
  180.             $brickTypeUsageCounter = $this->brickTypeUsageCounter[$this->currentIndex['type']] ?? 0;
  181.             if ($brickTypeUsageCounter >= $brickTypeLimit) {
  182.                 $disabled = true;
  183.             }
  185.             if (!$this->getEditableHandler()->isBrickEnabled($this, $index['type']) && ($config['dontCheckEnabled'] ?? false) !== true) {
  186.                 $disabled = true;
  187.             }
  189.             $this->blockStarted = false;
  190.             $info = $this->buildInfoObject();
  192.             if (!$manual && !$disabled) {
  193.                 $this->blockConstruct();
  194.                 $templateParams = $this->blockStart($info);
  196.                 $this->content($info, $templateParams);
  197.             } elseif (!$manual) {
  198.                 $this->current++;
  199.             }
  201.             return true;
  202.         } else {
  203.             if (!$manual) {
  204.                 $this->end();
  205.             }
  207.             return false;
  208.         }
  209.     }
  211.     /**
  212.      * @internal
  213.      *
  214.      * @return Area\Info
  215.      */
  216.     public function buildInfoObject(): Area\Info
  217.     {
  218.         $config = $this->getConfig();
  219.         // create info object and assign it to the view
  220.         $info = new Area\Info();
  221.         $info->setId($this->currentIndex ? $this->currentIndex['type'] : null);
  222.         $info->setEditable($this);
  223.         $info->setIndex($this->current);
  225.         $params = [];
  226.         if (is_array($config['params'][$this->currentIndex['type']] ?? null)) {
  227.             $params = $config['params'][$this->currentIndex['type']];
  228.         }
  230.         if (is_array($config['globalParams'] ?? null)) {
  231.             $params = array_merge($config['globalParams'], $params);
  232.         }
  234.         $info->setParams($params);
  236.         return $info;
  237.     }
  239.     /**
  240.      * @param null|Document\Editable\Area\Info $info
  241.      * @param array $templateParams
  242.      * @param bool $return
  243.      *
  244.      * @return string|void
  245.      */
  246.     public function content($info = null, $templateParams = [], $return = false)
  247.     {
  248.         if (!$info) {
  249.             $info = $this->buildInfoObject();
  250.         }
  252.         $content = '';
  254.         if ($this->editmode || !isset($this->currentIndex['hidden']) || !$this->currentIndex['hidden']) {
  255.             $templateParams['isAreaBlock'] = true;
  256.             $content = $this->getEditableHandler()->renderAreaFrontend($info, $templateParams);
  257.             if (!$return) {
  258.                 echo $content;
  259.             }
  260.             $this->brickTypeUsageCounter += [$this->currentIndex['type'] => 0];
  261.             $this->brickTypeUsageCounter[$this->currentIndex['type']]++;
  262.         }
  264.         $this->current++;
  266.         if ($return) {
  267.             return $content;
  268.         }
  269.     }
  271.     /**
  272.      * @internal
  273.      *
  274.      * @return EditableHandler
  275.      */
  276.     protected function getEditableHandler()
  277.     {
  278.         // TODO inject area handler via DI when editables are built through container
  279.         return \Pimcore::getContainer()->get(EditableHandler::class);
  280.     }
  282.     /**
  283.      * {@inheritdoc}
  284.      */
  285.     public function setDataFromResource($data)
  286.     {
  287.         $this->indices = Tool\Serialize::unserialize($data);
  288.         if (!is_array($this->indices)) {
  289.             $this->indices = [];
  290.         }
  292.         return $this;
  293.     }
  295.     /**
  296.      * {@inheritdoc}
  297.      */
  298.     public function setDataFromEditmode($data)
  299.     {
  300.         $this->indices = $data;
  302.         return $this;
  303.     }
  305.     /**
  306.      * {@inheritdoc}
  307.      */
  308.     public function blockConstruct()
  309.     {
  310.         // set the current block suffix for the child elements (0, 1, 3, ...)
  311.         // this will be removed in blockDestruct
  312.         $this->getBlockState()->pushIndex($this->indices[$this->current]['key']);
  313.     }
  315.     /**
  316.      * {@inheritdoc}
  317.      */
  318.     public function blockDestruct()
  319.     {
  320.         $this->getBlockState()->popIndex();
  321.     }
  323.     /**
  324.      * @return array
  325.      */
  326.     private function getToolBarDefaultConfig()
  327.     {
  328.         return [
  329.             'areablock_toolbar' => [
  330.                 'width' => 172,
  331.                 'buttonWidth' => 168,
  332.                 'buttonMaxCharacters' => 20,
  333.             ],
  334.         ];
  335.     }
  337.     /**
  338.      * {@inheritdoc}
  339.      */
  340.     public function getEditmodeDefinition(): array
  341.     {
  342.         $config = array_merge($this->getToolBarDefaultConfig(), $this->getConfig());
  344.         $options = parent::getEditmodeDefinition();
  345.         $options = array_merge($options, [
  346.             'config' => $config,
  347.         ]);
  349.         return $options;
  350.     }
  352.     /**
  353.      * {@inheritdoc}
  354.      */
  355.     protected function getEditmodeElementAttributes(): array
  356.     {
  357.         $attributes = parent::getEditmodeElementAttributes();
  359.         $attributes = array_merge($attributes, [
  360.             'name' => $this->getName(),
  361.             'type' => $this->getType(),
  362.         ]);
  364.         return $attributes;
  365.     }
  367.     /**
  368.      * @param bool $return
  369.      */
  370.     public function start($return = false)
  371.     {
  372.         if (($this->config['manual'] ?? false) === true) {
  373.             // in manual mode $this->render() is not called for the areablock, so we need to add
  374.             // the editable to the collector manually here
  375.             if ($editableDefCollector = $this->getEditableDefinitionCollector()) {
  376.                 $editableDefCollector->add($this);
  377.             }
  378.         }
  380.         reset($this->indices);
  382.         // set name suffix for the whole block element, this will be added to all child elements of the block
  383.         $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  385.         $attributes = $this->getEditmodeElementAttributes();
  386.         $attributeString = HtmlUtils::assembleAttributeString($attributes);
  388.         $html = '<div ' . $attributeString . '>';
  390.         if ($return) {
  391.             return $html;
  392.         } else {
  393.             $this->outputEditmode($html);
  394.         }
  396.         return $this;
  397.     }
  399.     /**
  400.      * @param bool $return
  401.      */
  402.     public function end($return = false)
  403.     {
  404.         $this->current = 0;
  406.         // remove the current block which was set by $this->start()
  407.         $this->getBlockState()->popBlock();
  409.         $html = '</div>';
  411.         if ($return) {
  412.             return $html;
  413.         } else {
  414.             $this->outputEditmode($html);
  415.         }
  416.     }
  418.     /**
  419.      * @param Document\Editable\Area\Info $info
  420.      */
  421.     public function blockStart($info = null)
  422.     {
  423.         $this->blockStarted = true;
  424.         $attributes = [
  425.             'data-name' => $this->getName(),
  426.             'data-real-name' => $this->getRealName(),
  427.         ];
  429.         $hidden = 'false';
  430.         if (isset($this->indices[$this->current]['hidden']) && $this->indices[$this->current]['hidden']) {
  431.             $hidden = 'true';
  432.         }
  434.         $outerAttributes = [
  435.             'key' => $this->indices[$this->current]['key'],
  436.             'type' => $this->indices[$this->current]['type'],
  437.             'data-hidden' => $hidden,
  438.         ];
  440.         $areabrickManager = \Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  442.         $dialogConfig = null;
  443.         $brick = $areabrickManager->getBrick($this->indices[$this->current]['type']);
  444.         if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  445.             $dialogConfig = $brick->getEditableDialogBoxConfiguration($this, $info);
  446.             if ($dialogConfig->getItems()) {
  447.                 $dialogConfig->setId('dialogBox-' . $this->getName() . '-' . $this->indices[$this->current]['key']);
  448.             } else {
  449.                 $dialogConfig = null;
  450.             }
  451.         }
  453.         $attr = HtmlUtils::assembleAttributeString($attributes);
  454.         $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  456.         $dialogAttributes = '';
  457.         if ($dialogConfig) {
  458.             $dialogAttributes = HtmlUtils::assembleAttributeString([
  459.                 'data-dialog-id' => $dialogConfig->getId(),
  460.             ]);
  461.         }
  463.         $dialogHtml = '';
  464.         if ($dialogConfig) {
  465.             $editableRenderer = \Pimcore::getContainer()->get(EditableRenderer::class);
  466.             $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer, $dialogConfig->getId(), $dialogHtml);
  467.         }
  469.         return [
  470.             'editmodeOuterAttributes' => $oAttr,
  471.             'editmodeGenericAttributes' => $attr,
  472.             'editableDialog' => $dialogConfig,
  473.             'editableDialogAttributes' => $dialogAttributes,
  474.             'dialogHtml' => $dialogHtml,
  475.         ];
  476.     }
  478.     /**
  479.      * This method needs to be `protected` as it is used in other bundles such as pimcore/headless-documents
  480.      *
  481.      * @param array $config
  482.      * @param EditableRenderer $editableRenderer
  483.      * @param string $dialogId
  484.      * @param string $html
  485.      *
  486.      * @throws \Exception
  487.      *
  488.      * @internal
  489.      */
  490.     protected function renderDialogBoxEditables(array $config, EditableRenderer $editableRenderer, string $dialogId, string &$html)
  491.     {
  492.         if (isset($config['items']) && is_array($config['items'])) {
  493.             // layout component
  494.             foreach ($config['items'] as $child) {
  495.                 $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  496.             }
  497.         } elseif (isset($config['name']) && isset($config['type'])) {
  498.             $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  499.             if (!$editable instanceof Document\Editable) {
  500.                 throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  501.             }
  503.             $editable->setInDialogBox($dialogId);
  504.             $editable->addConfig('dialogBoxConfig', $config);
  505.             $html .= $editable->render();
  506.         } elseif (is_array($config) && isset($config[0])) {
  507.             foreach ($config as $item) {
  508.                 $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  509.             }
  510.         }
  511.     }
  513.     /**
  514.      * {@inheritdoc}
  515.      */
  516.     public function blockEnd()
  517.     {
  518.         $this->blockStarted = false;
  519.     }
  521.     /**
  522.      * {@inheritdoc}
  523.      */
  524.     public function setConfig($config)
  525.     {
  526.         // we need to set this here otherwise custom areaDir's won't work
  527.         $this->config = $config;
  529.         if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  530.             $config['allowed'] = [];
  531.         }
  533.         $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  534.         $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  536.         $config['types'] = $availableAreas;
  538.         if (isset($config['group']) && is_array($config['group'])) {
  539.             $groupingareas = [];
  540.             foreach ($availableAreas as $area) {
  541.                 $groupingareas[$area['type']] = $area['type'];
  542.             }
  544.             $groups = [];
  545.             foreach ($config['group'] as $name => $areas) {
  546.                 $n = $name;
  547.                 $groups[$n] = $areas;
  549.                 foreach ($areas as $area) {
  550.                     unset($groupingareas[$area]);
  551.                 }
  552.             }
  554.             if (count($groupingareas) > 0) {
  555.                 $uncatAreas = [];
  556.                 foreach ($groupingareas as $area) {
  557.                     $uncatAreas[] = $area;
  558.                 }
  559.                 $n = 'Uncategorized';
  560.                 $groups[$n] = $uncatAreas;
  561.             }
  563.             $config['group'] = $groups;
  564.         }
  566.         if (empty($config['limit'])) {
  567.             $config['limit'] = 1000000;
  568.         }
  570.         $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  572.         $this->config = $config;
  574.         if (($this->config['manual'] ?? false) === true) {
  575.             $this->config['reload'] = true;
  576.         }
  578.         return $this;
  579.     }
  581.     /**
  582.      * Sorts areas by index (sorting option) first, then by name
  583.      *
  584.      * @param array $areas
  585.      * @param array $config
  586.      *
  587.      * @return array
  588.      */
  589.     private function sortAvailableAreas(array $areas, array $config)
  590.     {
  591.         if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  592.             $sorting = $config['sorting'];
  593.         } else {
  594.             if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  595.                 $sorting = $config['allowed'];
  596.             } else {
  597.                 $sorting = [];
  598.             }
  599.         }
  601.         $result = [
  602.             'name' => [],
  603.             'index' => [],
  604.         ];
  606.         foreach ($areas as $area) {
  607.             $sortIndex = false;
  608.             if (!empty($sorting)) {
  609.                 $sortIndex = array_search($area['type'], $sorting);
  610.             }
  612.             $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  613.             if (false !== $sortIndex) {
  614.                 $sortKey = 'index';
  615.                 $area['sortIndex'] = $sortIndex;
  616.             }
  618.             $result[$sortKey][] = $area;
  619.         }
  621.         // sort with translated names
  622.         if (count($result['name'])) {
  623.             usort($result['name'], function ($a, $b) {
  624.                 if ($a['name'] == $b['name']) {
  625.                     return 0;
  626.                 }
  628.                 return ($a['name'] < $b['name']) ? -1 : 1;
  629.             });
  630.         }
  632.         // sort by allowed brick config order
  633.         if (count($result['index'])) {
  634.             usort($result['index'], function ($a, $b) {
  635.                 return $a['sortIndex'] - $b['sortIndex'];
  636.             });
  637.         }
  639.         $result = array_merge($result['index'], $result['name']);
  641.         return $result;
  642.     }
  644.     /**
  645.      * {@inheritdoc}
  646.      */
  647.     public function getCount()
  648.     {
  649.         return count($this->indices);
  650.     }
  652.     /**
  653.      * {@inheritdoc}
  654.      */
  655.     public function getCurrent()
  656.     {
  657.         return $this->current - 1;
  658.     }
  660.     /**
  661.      * {@inheritdoc}
  662.      */
  663.     public function getCurrentIndex()
  664.     {
  665.         return $this->indices[$this->getCurrent()]['key'] ?? null;
  666.     }
  668.     /**
  669.      * @return array
  670.      */
  671.     public function getIndices()
  672.     {
  673.         return $this->indices;
  674.     }
  676.     /**
  677.      * If object was serialized, set the counter back to 0
  678.      */
  679.     public function __wakeup()
  680.     {
  681.         $this->current = 0;
  682.         reset($this->indices);
  683.     }
  685.     /**
  686.      * {@inheritdoc}
  687.      */
  688.     public function isEmpty()
  689.     {
  690.         return !(bool) count($this->indices);
  691.     }
  693.     /**
  694.      * @param string $name
  695.      *
  696.      * @return Areablock\Item[]
  697.      */
  698.     public function getElement(string $name)
  699.     {
  700.         $document = $this->getDocument();
  702.         $parentBlockNames = $this->getParentBlockNames();
  703.         $parentBlockNames[] = $this->getName();
  705.         $list = [];
  706.         foreach ($this->getData() as $index => $item) {
  707.             if ($item['type'] === $name) {
  708.                 $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  709.             }
  710.         }
  712.         return $list;
  713.     }
  714. }