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

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.      * This method needs to be `protected` as it is used in other bundles such as pimcore/headless-documents
  489.      *
  490.      * @param array $config
  491.      * @param EditableRenderer $editableRenderer
  492.      * @param string $dialogId
  493.      * @param string $html
  494.      *
  495.      * @throws \Exception
  496.      *
  497.      * @internal
  498.      */
  499.     protected function renderDialogBoxEditables(array $config, EditableRenderer $editableRenderer, string $dialogId, string &$html)
  500.     {
  501.         if (isset($config['items']) && is_array($config['items'])) {
  502.             // layout component
  503.             foreach ($config['items'] as $child) {
  504.                 $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  505.             }
  506.         } elseif (isset($config['name']) && isset($config['type'])) {
  507.             $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  508.             if (!$editable instanceof Document\Editable) {
  509.                 throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  510.             }
  512.             $editable->setInDialogBox($dialogId);
  513.             $editable->addConfig('dialogBoxConfig', $config);
  514.             $html .= $editable->render();
  515.         } elseif (is_array($config) && isset($config[0])) {
  516.             foreach ($config as $item) {
  517.                 $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  518.             }
  519.         }
  520.     }
  522.     /**
  523.      * {@inheritdoc}
  524.      */
  525.     public function blockEnd()
  526.     {
  527.         $this->blockStarted = false;
  528.     }
  530.     /**
  531.      * {@inheritdoc}
  532.      */
  533.     public function setConfig($config)
  534.     {
  535.         // we need to set this here otherwise custom areaDir's won't work
  536.         $this->config = $config;
  538.         if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  539.             $config['allowed'] = [];
  540.         }
  542.         $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  543.         $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  545.         $config['types'] = $availableAreas;
  547.         if (isset($config['group']) && is_array($config['group'])) {
  548.             $groupingareas = [];
  549.             foreach ($availableAreas as $area) {
  550.                 $groupingareas[$area['type']] = $area['type'];
  551.             }
  553.             $groups = [];
  554.             foreach ($config['group'] as $name => $areas) {
  555.                 $n = $name;
  556.                 $groups[$n] = $areas;
  558.                 foreach ($areas as $area) {
  559.                     unset($groupingareas[$area]);
  560.                 }
  561.             }
  563.             if (count($groupingareas) > 0) {
  564.                 $uncatAreas = [];
  565.                 foreach ($groupingareas as $area) {
  566.                     $uncatAreas[] = $area;
  567.                 }
  568.                 $n = 'Uncategorized';
  569.                 $groups[$n] = $uncatAreas;
  570.             }
  572.             $config['group'] = $groups;
  573.         }
  575.         if (empty($config['limit'])) {
  576.             $config['limit'] = 1000000;
  577.         }
  579.         $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  581.         $this->config = $config;
  583.         if (($this->config['manual'] ?? false) === true) {
  584.             $this->config['reload'] = true;
  585.         }
  587.         return $this;
  588.     }
  590.     /**
  591.      * Sorts areas by index (sorting option) first, then by name
  592.      *
  593.      * @param array $areas
  594.      * @param array $config
  595.      *
  596.      * @return array
  597.      */
  598.     private function sortAvailableAreas(array $areas, array $config)
  599.     {
  600.         if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  601.             $sorting = $config['sorting'];
  602.         } else {
  603.             if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  604.                 $sorting = $config['allowed'];
  605.             } else {
  606.                 $sorting = [];
  607.             }
  608.         }
  610.         $result = [
  611.             'name' => [],
  612.             'index' => [],
  613.         ];
  615.         foreach ($areas as $area) {
  616.             $sortIndex = false;
  617.             if (!empty($sorting)) {
  618.                 $sortIndex = array_search($area['type'], $sorting);
  619.             }
  621.             $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  622.             if (false !== $sortIndex) {
  623.                 $sortKey = 'index';
  624.                 $area['sortIndex'] = $sortIndex;
  625.             }
  627.             $result[$sortKey][] = $area;
  628.         }
  630.         // sort with translated names
  631.         if (count($result['name'])) {
  632.             usort($result['name'], function ($a, $b) {
  633.                 if ($a['name'] == $b['name']) {
  634.                     return 0;
  635.                 }
  637.                 return ($a['name'] < $b['name']) ? -1 : 1;
  638.             });
  639.         }
  641.         // sort by allowed brick config order
  642.         if (count($result['index'])) {
  643.             usort($result['index'], function ($a, $b) {
  644.                 return $a['sortIndex'] - $b['sortIndex'];
  645.             });
  646.         }
  648.         $result = array_merge($result['index'], $result['name']);
  650.         return $result;
  651.     }
  653.     /**
  654.      * {@inheritdoc}
  655.      */
  656.     public function getCount()
  657.     {
  658.         return count($this->indices);
  659.     }
  661.     /**
  662.      * {@inheritdoc}
  663.      */
  664.     public function getCurrent()
  665.     {
  666.         return $this->current - 1;
  667.     }
  669.     /**
  670.      * {@inheritdoc}
  671.      */
  672.     public function getCurrentIndex()
  673.     {
  674.         return $this->indices[$this->getCurrent()]['key'] ?? null;
  675.     }
  677.     /**
  678.      * @return array
  679.      */
  680.     public function getIndices()
  681.     {
  682.         return $this->indices;
  683.     }
  685.     /**
  686.      * If object was serialized, set the counter back to 0
  687.      */
  688.     public function __wakeup()
  689.     {
  690.         $this->current = 0;
  691.         reset($this->indices);
  692.     }
  694.     /**
  695.      * {@inheritdoc}
  696.      */
  697.     public function isEmpty()
  698.     {
  699.         return !(bool) count($this->indices);
  700.     }
  702.     /**
  703.      * @param string $name
  704.      *
  705.      * @return Areablock\Item[]
  706.      */
  707.     public function getElement(string $name)
  708.     {
  709.         $document = $this->getDocument();
  711.         $parentBlockNames = $this->getParentBlockNames();
  712.         $parentBlockNames[] = $this->getName();
  714.         $list = [];
  715.         foreach ($this->getData() as $index => $item) {
  716.             if ($item['type'] === $name) {
  717.                 $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  718.             }
  719.         }
  721.         return $list;
  722.     }
  723. }