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

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\Logger;
  23. use Pimcore\Model;
  24. use Pimcore\Model\Document;
  25. use Pimcore\Templating\Renderer\EditableRenderer;
  26. use Pimcore\Tool;
  27. use Pimcore\Tool\HtmlUtils;
  29. /**
  30.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  31.  */
  32. class Areablock extends Model\Document\Editable implements BlockInterface
  33. {
  34.     /**
  35.      * Contains an array of indices, which represent the order of the elements in the block
  36.      *
  37.      * @internal
  38.      *
  39.      * @var array
  40.      */
  41.     protected $indices = [];
  43.     /**
  44.      * Current step of the block while iteration
  45.      *
  46.      * @internal
  47.      *
  48.      * @var int
  49.      */
  50.     protected $current = 0;
  52.     /**
  53.      * @internal
  54.      *
  55.      * @var array
  56.      */
  57.     protected $currentIndex;
  59.     /**
  60.      * @internal
  61.      *
  62.      * @var bool
  63.      */
  64.     protected $blockStarted;
  66.     /**
  67.      * @internal
  68.      *
  69.      * @var array
  70.      */
  71.     protected $brickTypeUsageCounter = [];
  73.     /**
  74.      * {@inheritdoc}
  75.      */
  76.     public function getType()
  77.     {
  78.         return 'areablock';
  79.     }
  81.     /**
  82.      * {@inheritdoc}
  83.      */
  84.     public function getData()
  85.     {
  86.         return $this->indices;
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function admin()
  93.     {
  94.         $this->frontend();
  95.     }
  97.     /**
  98.      * {@inheritdoc}
  99.      */
  100.     public function frontend()
  101.     {
  102.         if (!is_array($this->indices)) {
  103.             $this->indices = [];
  104.         }
  105.         reset($this->indices);
  106.         while ($this->loop());
  107.     }
  109.     /**
  110.      * @internal
  111.      *
  112.      * @param int $index
  113.      * @param bool $return
  114.      */
  115.     public function renderIndex($index, $return = false)
  116.     {
  117.         $this->start($return);
  119.         $this->currentIndex = $this->indices[$index];
  120.         $this->current = $index;
  122.         $this->blockConstruct();
  123.         $templateParams = $this->blockStart();
  125.         $content = $this->content(null, $templateParams, $return);
  126.         if (!$return) {
  127.             echo $content;
  128.         }
  130.         $this->blockDestruct();
  131.         $this->blockEnd();
  132.         $this->end($return);
  134.         if ($return) {
  135.             return $content;
  136.         }
  137.     }
  139.     /**
  140.      * {@inheritdoc}
  141.      */
  142.     public function getIterator()
  143.     {
  144.         while ($this->loop()) {
  145.             yield $this->getCurrentIndex();
  146.         }
  147.     }
  149.     /**
  150.      * @internal
  151.      *
  152.      * @return bool
  153.      */
  154.     public function loop()
  155.     {
  156.         $disabled = false;
  157.         $config = $this->getConfig();
  158.         $manual = (($config['manual'] ?? false) == true);
  160.         if ($this->current > 0) {
  161.             if (!$manual && $this->blockStarted) {
  162.                 $this->blockDestruct();
  163.                 $this->blockEnd();
  164.             }
  165.         } else {
  166.             if (!$manual) {
  167.                 $this->start();
  168.             }
  169.         }
  171.         if ($this->current < count($this->indices) && $this->current < $config['limit']) {
  172.             $index = current($this->indices);
  173.             next($this->indices);
  175.             $this->currentIndex = $index;
  176.             if (!empty($config['allowed']) && !in_array($index['type'], $config['allowed'])) {
  177.                 $disabled = true;
  178.             }
  180.             $brickTypeLimit = $config['limits'][$this->currentIndex['type']] ?? 100000;
  181.             $brickTypeUsageCounter = $this->brickTypeUsageCounter[$this->currentIndex['type']] ?? 0;
  182.             if ($brickTypeUsageCounter >= $brickTypeLimit) {
  183.                 $disabled = true;
  184.             }
  186.             if (!$this->getEditableHandler()->isBrickEnabled($this, $index['type']) && $config['dontCheckEnabled'] != true) {
  187.                 $disabled = true;
  188.             }
  190.             $this->blockStarted = false;
  191.             $info = $this->buildInfoObject();
  193.             if (!$manual && !$disabled) {
  194.                 $this->blockConstruct();
  195.                 $templateParams = $this->blockStart($info);
  197.                 $this->content($info, $templateParams);
  198.             } elseif (!$manual) {
  199.                 $this->current++;
  200.             }
  202.             return true;
  203.         } else {
  204.             if (!$manual) {
  205.                 $this->end();
  206.             }
  208.             return false;
  209.         }
  210.     }
  212.     /**
  213.      * @internal
  214.      *
  215.      * @return Area\Info
  216.      */
  217.     public function buildInfoObject(): Area\Info
  218.     {
  219.         // create info object and assign it to the view
  220.         $info = new Area\Info();
  222.         try {
  223.             $info->setId($this->currentIndex ? $this->currentIndex['type'] : null);
  224.             $info->setEditable($this);
  225.             $info->setIndex($this->current);
  226.         } catch (\Exception $e) {
  227.             Logger::err($e);
  228.         }
  230.         $params = [];
  232.         $config = $this->getConfig();
  233.         if (isset($config['params']) && is_array($config['params']) && array_key_exists($this->currentIndex['type'], $config['params'])) {
  234.             if (is_array($config['params'][$this->currentIndex['type']])) {
  235.                 $params = $config['params'][$this->currentIndex['type']];
  236.             }
  237.         }
  239.         if (isset($config['globalParams'])) {
  240.             $params = array_merge($config['globalParams'], (array)$params);
  241.         }
  243.         $info->setParams($params);
  245.         return $info;
  246.     }
  248.     /**
  249.      * @param null|Document\Editable\Area\Info $info
  250.      * @param array $templateParams
  251.      * @param bool $return
  252.      *
  253.      * @return string|void
  254.      */
  255.     public function content($info = null, $templateParams = [], $return = false)
  256.     {
  257.         if (!$info) {
  258.             $info = $this->buildInfoObject();
  259.         }
  261.         $content = '';
  263.         if ($this->editmode || !isset($this->currentIndex['hidden']) || !$this->currentIndex['hidden']) {
  264.             $templateParams['isAreaBlock'] = true;
  265.             $content = $this->getEditableHandler()->renderAreaFrontend($info, $templateParams);
  266.             if (!$return) {
  267.                 echo $content;
  268.             }
  269.             $this->brickTypeUsageCounter += [$this->currentIndex['type'] => 0];
  270.             $this->brickTypeUsageCounter[$this->currentIndex['type']]++;
  271.         }
  273.         $this->current++;
  275.         if ($return) {
  276.             return $content;
  277.         }
  278.     }
  280.     /**
  281.      * @internal
  282.      *
  283.      * @return EditableHandler
  284.      */
  285.     protected function getEditableHandler()
  286.     {
  287.         // TODO inject area handler via DI when editables are built through container
  288.         return \Pimcore::getContainer()->get(EditableHandler::class);
  289.     }
  291.     /**
  292.      * {@inheritdoc}
  293.      */
  294.     public function setDataFromResource($data)
  295.     {
  296.         $this->indices = Tool\Serialize::unserialize($data);
  297.         if (!is_array($this->indices)) {
  298.             $this->indices = [];
  299.         }
  301.         return $this;
  302.     }
  304.     /**
  305.      * {@inheritdoc}
  306.      */
  307.     public function setDataFromEditmode($data)
  308.     {
  309.         $this->indices = $data;
  311.         return $this;
  312.     }
  314.     /**
  315.      * {@inheritdoc}
  316.      */
  317.     public function blockConstruct()
  318.     {
  319.         // set the current block suffix for the child elements (0, 1, 3, ...)
  320.         // this will be removed in blockDestruct
  321.         $this->getBlockState()->pushIndex($this->indices[$this->current]['key']);
  322.     }
  324.     /**
  325.      * {@inheritdoc}
  326.      */
  327.     public function blockDestruct()
  328.     {
  329.         $this->getBlockState()->popIndex();
  330.     }
  332.     /**
  333.      * @return array
  334.      */
  335.     private function getToolBarDefaultConfig()
  336.     {
  337.         return [
  338.             'areablock_toolbar' => [
  339.                 'width' => 172,
  340.                 'buttonWidth' => 168,
  341.                 'buttonMaxCharacters' => 20,
  342.             ],
  343.         ];
  344.     }
  346.     /**
  347.      * {@inheritdoc}
  348.      */
  349.     public function getEditmodeDefinition(): array
  350.     {
  351.         $config = array_merge($this->getToolBarDefaultConfig(), $this->getConfig());
  353.         $options = parent::getEditmodeDefinition();
  354.         $options = array_merge($options, [
  355.             'config' => $config,
  356.         ]);
  358.         return $options;
  359.     }
  361.     /**
  362.      * {@inheritdoc}
  363.      */
  364.     protected function getEditmodeElementAttributes(): array
  365.     {
  366.         $attributes = parent::getEditmodeElementAttributes();
  368.         $attributes = array_merge($attributes, [
  369.             'name' => $this->getName(),
  370.             'type' => $this->getType(),
  371.         ]);
  373.         return $attributes;
  374.     }
  376.     /**
  377.      * {@inheritdoc}
  378.      */
  379.     public function start($return = false)
  380.     {
  381.         if (($this->config['manual'] ?? false) === true) {
  382.             // in manual mode $this->render() is not called for the areablock, so we need to add
  383.             // the editable to the collector manually here
  384.             if ($editableDefCollector = $this->getEditableDefinitionCollector()) {
  385.                 $editableDefCollector->add($this);
  386.             }
  387.         }
  389.         reset($this->indices);
  391.         // set name suffix for the whole block element, this will be added to all child elements of the block
  392.         $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  394.         $attributes = $this->getEditmodeElementAttributes();
  395.         $attributeString = HtmlUtils::assembleAttributeString($attributes);
  397.         $html = '<div ' . $attributeString . '>';
  399.         if ($return) {
  400.             return $html;
  401.         } else {
  402.             $this->outputEditmode($html);
  403.         }
  405.         return $this;
  406.     }
  408.     /**
  409.      * {@inheritdoc}
  410.      */
  411.     public function end($return = false)
  412.     {
  413.         $this->current = 0;
  415.         // remove the current block which was set by $this->start()
  416.         $this->getBlockState()->popBlock();
  418.         $html = '</div>';
  420.         if ($return) {
  421.             return $html;
  422.         } else {
  423.             $this->outputEditmode($html);
  424.         }
  425.     }
  427.     /**
  428.      * {@inheritdoc}
  429.      */
  430.     public function blockStart($info = null)
  431.     {
  432.         $this->blockStarted = true;
  433.         $attributes = [
  434.             'data-name' => $this->getName(),
  435.             'data-real-name' => $this->getRealName(),
  436.         ];
  438.         $hidden = 'false';
  439.         if (isset($this->indices[$this->current]['hidden']) && $this->indices[$this->current]['hidden']) {
  440.             $hidden = 'true';
  441.         }
  443.         $outerAttributes = [
  444.             'key' => $this->indices[$this->current]['key'],
  445.             'type' => $this->indices[$this->current]['type'],
  446.             'data-hidden' => $hidden,
  447.         ];
  449.         $areabrickManager = \Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  451.         $dialogConfig = null;
  452.         $brick = $areabrickManager->getBrick($this->indices[$this->current]['type']);
  453.         if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  454.             $dialogConfig = $brick->getEditableDialogBoxConfiguration($this, $info);
  455.             if ($dialogConfig->getItems()) {
  456.                 $dialogConfig->setId('dialogBox-' . $this->getName() . '-' . $this->indices[$this->current]['key']);
  457.             } else {
  458.                 $dialogConfig = null;
  459.             }
  460.         }
  462.         $attr = HtmlUtils::assembleAttributeString($attributes);
  463.         $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  465.         $dialogAttributes = '';
  466.         if ($dialogConfig) {
  467.             $dialogAttributes = HtmlUtils::assembleAttributeString([
  468.                 'data-dialog-id' => $dialogConfig->getId(),
  469.             ]);
  470.         }
  472.         $dialogHtml = '';
  473.         if ($dialogConfig) {
  474.             $editableRenderer = \Pimcore::getContainer()->get(EditableRenderer::class);
  475.             $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer, $dialogConfig->getId(), $dialogHtml);
  476.         }
  478.         return [
  479.             'editmodeOuterAttributes' => $oAttr,
  480.             'editmodeGenericAttributes' => $attr,
  481.             'editableDialog' => $dialogConfig,
  482.             'editableDialogAttributes' => $dialogAttributes,
  483.             'dialogHtml' => $dialogHtml,
  484.         ];
  485.     }
  487.     /**
  488.      * @param array $config
  489.      * @param EditableRenderer $editableRenderer
  490.      * @param string $dialogId
  491.      * @param string $html
  492.      *
  493.      * @throws \Exception
  494.      */
  495.     private function renderDialogBoxEditables(array $config, EditableRenderer $editableRenderer, string $dialogId, string &$html)
  496.     {
  497.         if (isset($config['items']) && is_array($config['items'])) {
  498.             // layout component
  499.             foreach ($config['items'] as $child) {
  500.                 $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  501.             }
  502.         } elseif (isset($config['name']) && isset($config['type'])) {
  503.             $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  504.             if (!$editable instanceof Document\Editable) {
  505.                 throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  506.             }
  508.             $editable->setInDialogBox($dialogId);
  509.             $editable->addConfig('dialogBoxConfig', $config);
  510.             $html .= $editable->render();
  511.         } elseif (is_array($config) && isset($config[0])) {
  512.             foreach ($config as $item) {
  513.                 $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  514.             }
  515.         }
  516.     }
  518.     /**
  519.      * {@inheritdoc}
  520.      */
  521.     public function blockEnd()
  522.     {
  523.         $this->blockStarted = false;
  524.     }
  526.     /**
  527.      * {@inheritdoc}
  528.      */
  529.     public function setConfig($config)
  530.     {
  531.         // we need to set this here otherwise custom areaDir's won't work
  532.         $this->config = $config;
  534.         if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  535.             $config['allowed'] = [];
  536.         }
  538.         $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  539.         $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  541.         $config['types'] = $availableAreas;
  543.         if (isset($config['group']) && is_array($config['group'])) {
  544.             $groupingareas = [];
  545.             foreach ($availableAreas as $area) {
  546.                 $groupingareas[$area['type']] = $area['type'];
  547.             }
  549.             $groups = [];
  550.             foreach ($config['group'] as $name => $areas) {
  551.                 $n = $name;
  552.                 $groups[$n] = $areas;
  554.                 foreach ($areas as $area) {
  555.                     unset($groupingareas[$area]);
  556.                 }
  557.             }
  559.             if (count($groupingareas) > 0) {
  560.                 $uncatAreas = [];
  561.                 foreach ($groupingareas as $area) {
  562.                     $uncatAreas[] = $area;
  563.                 }
  564.                 $n = 'Uncategorized';
  565.                 $groups[$n] = $uncatAreas;
  566.             }
  568.             $config['group'] = $groups;
  569.         }
  571.         if (empty($config['limit'])) {
  572.             $config['limit'] = 1000000;
  573.         }
  575.         $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  577.         $this->config = $config;
  579.         if (($this->config['manual'] ?? false) === true) {
  580.             $this->config['reload'] = true;
  581.         }
  583.         return $this;
  584.     }
  586.     /**
  587.      * Sorts areas by index (sorting option) first, then by name
  588.      *
  589.      * @param array $areas
  590.      * @param array $config
  591.      *
  592.      * @return array
  593.      */
  594.     private function sortAvailableAreas(array $areas, array $config)
  595.     {
  596.         if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  597.             $sorting = $config['sorting'];
  598.         } else {
  599.             if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  600.                 $sorting = $config['allowed'];
  601.             } else {
  602.                 $sorting = [];
  603.             }
  604.         }
  606.         $result = [
  607.             'name' => [],
  608.             'index' => [],
  609.         ];
  611.         foreach ($areas as $area) {
  612.             $sortIndex = false;
  613.             if (!empty($sorting)) {
  614.                 $sortIndex = array_search($area['type'], $sorting);
  615.             }
  617.             $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  618.             if (false !== $sortIndex) {
  619.                 $sortKey = 'index';
  620.                 $area['sortIndex'] = $sortIndex;
  621.             }
  623.             $result[$sortKey][] = $area;
  624.         }
  626.         // sort with translated names
  627.         if (count($result['name'])) {
  628.             usort($result['name'], function ($a, $b) {
  629.                 if ($a['name'] == $b['name']) {
  630.                     return 0;
  631.                 }
  633.                 return ($a['name'] < $b['name']) ? -1 : 1;
  634.             });
  635.         }
  637.         // sort by allowed brick config order
  638.         if (count($result['index'])) {
  639.             usort($result['index'], function ($a, $b) {
  640.                 return $a['sortIndex'] - $b['sortIndex'];
  641.             });
  642.         }
  644.         $result = array_merge($result['index'], $result['name']);
  646.         return $result;
  647.     }
  649.     /**
  650.      * {@inheritdoc}
  651.      */
  652.     public function getCount()
  653.     {
  654.         return count($this->indices);
  655.     }
  657.     /**
  658.      * {@inheritdoc}
  659.      */
  660.     public function getCurrent()
  661.     {
  662.         return $this->current - 1;
  663.     }
  665.     /**
  666.      * {@inheritdoc}
  667.      */
  668.     public function getCurrentIndex()
  669.     {
  670.         return $this->indices[$this->getCurrent()]['key'] ?? null;
  671.     }
  673.     /**
  674.      * @return array
  675.      */
  676.     public function getIndices()
  677.     {
  678.         return $this->indices;
  679.     }
  681.     /**
  682.      * If object was serialized, set the counter back to 0
  683.      */
  684.     public function __wakeup()
  685.     {
  686.         $this->current = 0;
  687.         reset($this->indices);
  688.     }
  690.     /**
  691.      * {@inheritdoc}
  692.      */
  693.     public function isEmpty()
  694.     {
  695.         return !(bool) count($this->indices);
  696.     }
  698.     /**
  699.      * @param string $name
  700.      *
  701.      * @return Areablock\Item[]
  702.      */
  703.     public function getElement(string $name)
  704.     {
  705.         $document = $this->getDocument();
  707.         $parentBlockNames = $this->getParentBlockNames();
  708.         $parentBlockNames[] = $this->getName();
  710.         $list = [];
  711.         foreach ($this->getData() as $index => $item) {
  712.             if ($item['type'] === $name) {
  713.                 $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  714.             }
  715.         }
  717.         return $list;
  718.     }
  719. }