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

  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.      */
  39.     protected array $indices = [];
  41.     /**
  42.      * Current step of the block while iteration
  43.      *
  44.      * @internal
  45.      *
  46.      */
  47.     protected int $current = 0;
  49.     /**
  50.      * @internal
  51.      *
  52.      */
  53.     protected ?array $currentIndex = null;
  55.     /**
  56.      * @internal
  57.      *
  58.      */
  59.     protected ?bool $blockStarted = false;
  61.     /**
  62.      * @internal
  63.      *
  64.      */
  65.     protected array $brickTypeUsageCounter = [];
  67.     public function getType(): string
  68.     {
  69.         return 'areablock';
  70.     }
  72.     public function getData(): mixed
  73.     {
  74.         return $this->indices;
  75.     }
  77.     public function admin(): void
  78.     {
  79.         $this->frontend();
  80.     }
  82.     public function frontend(): void
  83.     {
  84.         reset($this->indices);
  85.         while ($this->loop());
  86.     }
  88.     /**
  89.      * @internal
  90.      *
  91.      * @return ($return is true ? string : void)
  92.      */
  93.     public function renderIndex(int $index, bool $return = false)
  94.     {
  95.         $this->start($return);
  97.         $this->currentIndex = $this->indices[$index];
  98.         $this->current = $index;
  100.         $this->blockConstruct();
  101.         $templateParams = $this->blockStart();
  103.         $content = $this->content(null, $templateParams, $return);
  104.         if (!$return) {
  105.             echo $content;
  106.         }
  108.         $this->blockDestruct();
  109.         $this->blockEnd();
  110.         $this->end($return);
  112.         if ($return) {
  113.             return $content;
  114.         }
  115.     }
  117.     public function getIterator(): \Generator
  118.     {
  119.         while ($this->loop()) {
  120.             yield $this->getCurrentIndex();
  121.         }
  122.     }
  124.     /**
  125.      * @internal
  126.      *
  127.      */
  128.     public function loop(): bool
  129.     {
  130.         $disabled = false;
  131.         $config = $this->getConfig();
  132.         $manual = (($config['manual'] ?? false) == true);
  134.         if ($this->current > 0) {
  135.             if (!$manual && $this->blockStarted) {
  136.                 $this->blockDestruct();
  137.                 $this->blockEnd();
  138.             }
  139.         } else {
  140.             if (!$manual) {
  141.                 $this->start();
  142.             }
  143.         }
  145.         if ($this->current < count($this->indices) && $this->current < $config['limit']) {
  146.             $index = current($this->indices);
  147.             next($this->indices);
  149.             $this->currentIndex = $index;
  150.             if (!empty($config['allowed']) && !in_array($index['type'], $config['allowed'])) {
  151.                 $disabled = true;
  152.             }
  154.             $brickTypeLimit = $config['limits'][$this->currentIndex['type']] ?? 100000;
  155.             $brickTypeUsageCounter = $this->brickTypeUsageCounter[$this->currentIndex['type']] ?? 0;
  156.             if ($brickTypeUsageCounter >= $brickTypeLimit) {
  157.                 $disabled = true;
  158.             }
  160.             $this->blockStarted = false;
  161.             $info = $this->buildInfoObject();
  163.             if (!$manual && !$disabled) {
  164.                 $this->blockConstruct();
  165.                 $templateParams = $this->blockStart($info);
  167.                 $this->content($info, $templateParams);
  168.             } elseif (!$manual) {
  169.                 $this->current++;
  170.             }
  172.             return true;
  173.         } else {
  174.             if (!$manual) {
  175.                 $this->end();
  176.             }
  178.             return false;
  179.         }
  180.     }
  182.     /**
  183.      * @internal
  184.      *
  185.      */
  186.     public function buildInfoObject(): Area\Info
  187.     {
  188.         $config = $this->getConfig();
  189.         // create info object and assign it to the view
  190.         $info = new Area\Info();
  191.         $info->setId($this->currentIndex ? $this->currentIndex['type'] : null);
  192.         $info->setEditable($this);
  193.         $info->setIndex($this->current);
  195.         $params = [];
  196.         if (is_array($config['params'][$this->currentIndex['type']] ?? null)) {
  197.             $params = $config['params'][$this->currentIndex['type']];
  198.         }
  200.         if (is_array($config['globalParams'] ?? null)) {
  201.             $params = array_merge($config['globalParams'], $params);
  202.         }
  204.         $info->setParams($params);
  206.         return $info;
  207.     }
  209.     /**
  210.      * @param null|Document\Editable\Area\Info $info
  211.      *
  212.      * @return string|void
  213.      */
  214.     public function content(Area\Info $info = null, array $templateParams = [], bool $return = false)
  215.     {
  216.         if (!$info) {
  217.             $info = $this->buildInfoObject();
  218.         }
  220.         $content = '';
  222.         if ($this->editmode || !isset($this->currentIndex['hidden']) || !$this->currentIndex['hidden']) {
  223.             $templateParams['isAreaBlock'] = true;
  224.             $content = $this->getEditableHandler()->renderAreaFrontend($info, $templateParams);
  225.             if (!$return) {
  226.                 echo $content;
  227.             }
  228.             $this->brickTypeUsageCounter += [$this->currentIndex['type'] => 0];
  229.             $this->brickTypeUsageCounter[$this->currentIndex['type']]++;
  230.         }
  232.         $this->current++;
  234.         if ($return) {
  235.             return $content;
  236.         }
  237.     }
  239.     /**
  240.      * @internal
  241.      *
  242.      */
  243.     protected function getEditableHandler(): EditableHandler
  244.     {
  245.         // TODO inject area handler via DI when editables are built through container
  246.         return \Pimcore::getContainer()->get(EditableHandler::class);
  247.     }
  249.     public function setDataFromResource(mixed $data): static
  250.     {
  251.         $unserializedData = Tool\Serialize::unserialize($data);
  253.         if (is_array($unserializedData)) {
  254.             $this->indices = $unserializedData;
  255.         } else {
  256.             $this->indices = [];
  257.         }
  259.         return $this;
  260.     }
  262.     public function setDataFromEditmode(mixed $data): static
  263.     {
  264.         $this->indices = $data;
  266.         return $this;
  267.     }
  269.     public function blockConstruct(): void
  270.     {
  271.         // set the current block suffix for the child elements (0, 1, 3, ...)
  272.         // this will be removed in blockDestruct
  273.         $this->getBlockState()->pushIndex($this->indices[$this->current]['key']);
  274.     }
  276.     public function blockDestruct(): void
  277.     {
  278.         $this->getBlockState()->popIndex();
  279.     }
  281.     private function getToolBarDefaultConfig(): array
  282.     {
  283.         return [
  284.             'areablock_toolbar' => [
  285.                 'width' => 172,
  286.                 'buttonWidth' => 168,
  287.                 'buttonMaxCharacters' => 20,
  288.             ],
  289.         ];
  290.     }
  292.     public function getEditmodeDefinition(): array
  293.     {
  294.         $config = array_merge($this->getToolBarDefaultConfig(), $this->getConfig());
  296.         $options = parent::getEditmodeDefinition();
  297.         $options = array_merge($options, [
  298.             'config' => $config,
  299.         ]);
  301.         return $options;
  302.     }
  304.     protected function getEditmodeElementAttributes(): array
  305.     {
  306.         $attributes = parent::getEditmodeElementAttributes();
  308.         $attributes = array_merge($attributes, [
  309.             'name' => $this->getName(),
  310.             'type' => $this->getType(),
  311.         ]);
  313.         return $attributes;
  314.     }
  316.     public function start(bool $return = false)
  317.     {
  318.         if (($this->config['manual'] ?? false) === true) {
  319.             // in manual mode $this->render() is not called for the areablock, so we need to add
  320.             // the editable to the collector manually here
  321.             if ($editableDefCollector = $this->getEditableDefinitionCollector()) {
  322.                 $editableDefCollector->add($this);
  323.             }
  324.         }
  326.         reset($this->indices);
  328.         // set name suffix for the whole block element, this will be added to all child elements of the block
  329.         $this->getBlockState()->pushBlock(BlockName::createFromEditable($this));
  331.         $attributes = $this->getEditmodeElementAttributes();
  332.         $attributeString = HtmlUtils::assembleAttributeString($attributes);
  334.         $html = '<div ' . $attributeString . '>';
  336.         if ($return) {
  337.             return $html;
  338.         }
  340.         $this->outputEditmode($html);
  342.         return $this;
  343.     }
  345.     public function end(bool $return = false)
  346.     {
  347.         $this->current = 0;
  349.         // remove the current block which was set by $this->start()
  350.         $this->getBlockState()->popBlock();
  352.         $html = '</div>';
  354.         if ($return) {
  355.             return $html;
  356.         }
  358.         $this->outputEditmode($html);
  359.     }
  361.     public function blockStart(Area\Info $info = null): array
  362.     {
  363.         $this->blockStarted = true;
  364.         $attributes = [
  365.             'data-name' => $this->getName(),
  366.             'data-real-name' => $this->getRealName(),
  367.         ];
  369.         $hidden = 'false';
  370.         if (isset($this->indices[$this->current]['hidden']) && $this->indices[$this->current]['hidden']) {
  371.             $hidden = 'true';
  372.         }
  374.         $outerAttributes = [
  375.             'key' => $this->indices[$this->current]['key'],
  376.             'type' => $this->indices[$this->current]['type'],
  377.             'data-hidden' => $hidden,
  378.         ];
  380.         $areabrickManager = \Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  382.         $dialogConfig = null;
  383.         $brick = $areabrickManager->getBrick($this->indices[$this->current]['type']);
  384.         if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  385.             $dialogConfig = $brick->getEditableDialogBoxConfiguration($this, $info);
  386.             if ($dialogConfig->getItems()) {
  387.                 $dialogConfig->setId('dialogBox-' . $this->getName() . '-' . $this->indices[$this->current]['key']);
  388.             } else {
  389.                 $dialogConfig = null;
  390.             }
  391.         }
  393.         $attr = HtmlUtils::assembleAttributeString($attributes);
  394.         $oAttr = HtmlUtils::assembleAttributeString($outerAttributes);
  396.         $dialogAttributes = '';
  397.         if ($dialogConfig) {
  398.             $dialogAttributes = HtmlUtils::assembleAttributeString([
  399.                 'data-dialog-id' => $dialogConfig->getId(),
  400.             ]);
  401.         }
  403.         $dialogHtml = '';
  404.         if ($dialogConfig) {
  405.             $editableRenderer = \Pimcore::getContainer()->get(EditableRenderer::class);
  406.             $items = $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer, $dialogConfig->getId(), $dialogHtml);
  407.             $dialogConfig->setItems($items);
  408.         }
  410.         return [
  411.             'editmodeOuterAttributes' => $oAttr,
  412.             'editmodeGenericAttributes' => $attr,
  413.             'editableDialog' => $dialogConfig,
  414.             'editableDialogAttributes' => $dialogAttributes,
  415.             'dialogHtml' => $dialogHtml,
  416.         ];
  417.     }
  419.     /**
  420.      * This method needs to be `protected` as it is used in other bundles such as pimcore/headless-documents
  421.      *
  422.      *
  423.      * @throws \Exception
  424.      *
  425.      * @internal
  426.      */
  427.     protected function renderDialogBoxEditables(array|Document\Editable $config, EditableRenderer $editableRenderer, string $dialogId, string &$html): array
  428.     {
  429.         if ($config instanceof BlockInterface || $config instanceof Area) {
  430.             // Unsupported element was passed (e.g., Block, Areablock, ...)
  431.             // or an Areas was passed, which is not supported to avoid too long editable names
  432.             throw new \Exception(sprintf('Using editables of type "%s" for the editable dialog "%s" is not supported.', get_debug_type($config), $dialogId));
  433.         } elseif ($config instanceof Document\Editable) {
  434.             // Map editable to array config
  435.             $config = [
  436.                 'type' => $config->getType(),
  437.                 'name' => $config->getName(),
  438.                 'label' => $config->getLabel(),
  439.                 'config' => $config->getConfig(),
  440.                 'description' => $config->getDialogDescription(),
  441.             ];
  442.         }
  444.         if (isset($config['items']) && is_array($config['items'])) {
  445.             // layout component
  446.             foreach ($config['items'] as $index => $child) {
  447.                 $config['items'][$index] = $this->renderDialogBoxEditables($child, $editableRenderer, $dialogId, $html);
  448.             }
  449.         } elseif (isset($config['name']) && isset($config['type'])) {
  450.             $editable = $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  451.             if (!$editable instanceof Document\Editable) {
  452.                 throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box', $config['type']));
  453.             }
  455.             $editable->setInDialogBox($dialogId);
  456.             $editable->addConfig('dialogBoxConfig', $config);
  457.             $html .= $editable->render();
  458.         } else {
  459.             foreach ($config as $index => $item) {
  460.                 $config['items'][$index] = $this->renderDialogBoxEditables($item, $editableRenderer, $dialogId, $html);
  461.             }
  462.         }
  464.         return $config;
  465.     }
  467.     public function blockEnd(): void
  468.     {
  469.         $this->blockStarted = false;
  470.     }
  472.     public function setConfig(array $config): static
  473.     {
  474.         // we need to set this here otherwise custom areaDir's won't work
  475.         $this->config = $config;
  477.         if (!isset($config['allowed']) || !is_array($config['allowed'])) {
  478.             $config['allowed'] = [];
  479.         }
  481.         $availableAreas = $this->getEditableHandler()->getAvailableAreablockAreas($this, $config);
  482.         $availableAreas = $this->sortAvailableAreas($availableAreas, $config);
  484.         $config['types'] = $availableAreas;
  486.         if (isset($config['group']) && is_array($config['group'])) {
  487.             $groupingareas = [];
  488.             foreach ($availableAreas as $area) {
  489.                 $groupingareas[$area['type']] = $area['type'];
  490.             }
  492.             $groups = [];
  493.             foreach ($config['group'] as $name => $areas) {
  494.                 $n = $name;
  495.                 $groups[$n] = $areas;
  497.                 foreach ($areas as $area) {
  498.                     unset($groupingareas[$area]);
  499.                 }
  500.             }
  502.             if (count($groupingareas) > 0) {
  503.                 $uncatAreas = [];
  504.                 foreach ($groupingareas as $area) {
  505.                     $uncatAreas[] = $area;
  506.                 }
  507.                 $n = 'Uncategorized';
  508.                 $groups[$n] = $uncatAreas;
  509.             }
  511.             $config['group'] = $groups;
  512.         }
  514.         if (empty($config['limit'])) {
  515.             $config['limit'] = 1000000;
  516.         }
  518.         $config['blockStateStack'] = json_encode($this->getBlockStateStack());
  520.         $this->config = $config;
  522.         if (($this->config['manual'] ?? false) === true) {
  523.             $this->config['reload'] = true;
  524.         }
  526.         return $this;
  527.     }
  529.     /**
  530.      * Sorts areas by index (sorting option) first, then by name
  531.      */
  532.     private function sortAvailableAreas(array $areas, array $config): array
  533.     {
  534.         if (isset($config['sorting']) && is_array($config['sorting']) && count($config['sorting'])) {
  535.             $sorting = $config['sorting'];
  536.         } else {
  537.             if (isset($config['allowed']) && is_array($config['allowed']) && count($config['allowed'])) {
  538.                 $sorting = $config['allowed'];
  539.             } else {
  540.                 $sorting = [];
  541.             }
  542.         }
  544.         $result = [
  545.             'name' => [],
  546.             'index' => [],
  547.         ];
  549.         foreach ($areas as $area) {
  550.             $sortIndex = false;
  551.             if (!empty($sorting)) {
  552.                 $sortIndex = array_search($area['type'], $sorting);
  553.             }
  555.             $sortKey = 'name'; // allowed and sorting is not set || areaName is not in allowed
  556.             if (false !== $sortIndex) {
  557.                 $sortKey = 'index';
  558.                 $area['sortIndex'] = $sortIndex;
  559.             }
  561.             $result[$sortKey][] = $area;
  562.         }
  564.         // sort with translated names
  565.         if (count($result['name'])) {
  566.             usort($result['name'], function ($a, $b) {
  567.                 if ($a['name'] == $b['name']) {
  568.                     return 0;
  569.                 }
  571.                 return ($a['name'] < $b['name']) ? -1 : 1;
  572.             });
  573.         }
  575.         // sort by allowed brick config order
  576.         if (count($result['index'])) {
  577.             usort($result['index'], function ($a, $b) {
  578.                 return $a['sortIndex'] - $b['sortIndex'];
  579.             });
  580.         }
  582.         $result = array_merge($result['index'], $result['name']);
  584.         return $result;
  585.     }
  587.     public function getCount(): int
  588.     {
  589.         return count($this->indices);
  590.     }
  592.     public function getCurrent(): int
  593.     {
  594.         return $this->current - 1;
  595.     }
  597.     public function getCurrentIndex(): int
  598.     {
  599.         return $this->indices[$this->getCurrent()]['key'] ?? 0;
  600.     }
  602.     public function getIndices(): array
  603.     {
  604.         return $this->indices;
  605.     }
  607.     /**
  608.      * If object was serialized, set the counter back to 0
  609.      */
  610.     public function __wakeup(): void
  611.     {
  612.         $this->current = 0;
  613.         reset($this->indices);
  614.     }
  616.     public function isEmpty(): bool
  617.     {
  618.         return !(bool) count($this->indices);
  619.     }
  621.     /**
  622.      *
  623.      * @return Areablock\Item[]
  624.      */
  625.     public function getElement(string $name): array
  626.     {
  627.         $document = $this->getDocument();
  629.         $parentBlockNames = $this->getParentBlockNames();
  630.         $parentBlockNames[] = $this->getName();
  632.         $list = [];
  633.         foreach ($this->getData() as $index => $item) {
  634.             if ($item['type'] === $name) {
  635.                 $list[$index] = new Areablock\Item($document, $parentBlockNames, (int)$item['key']);
  636.             }
  637.         }
  639.         return $list;
  640.     }
  641. }