vendor/pimcore/pimcore/models/Document/Editable/Area.php line 215

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Commercial License (PCL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  13.  */
  14. namespace Pimcore\Model\Document\Editable;
  15. use Pimcore\Document\Editable\Block\BlockName;
  16. use Pimcore\Document\Editable\EditableHandler;
  17. use Pimcore\Extension\Document\Areabrick\AreabrickManagerInterface;
  18. use Pimcore\Extension\Document\Areabrick\EditableDialogBoxInterface;
  19. use Pimcore\Model;
  20. use Pimcore\Templating\Renderer\EditableRenderer;
  21. use Pimcore\Tool\HtmlUtils;
  22. use Pimcore\Tool\Serialize;
  23. /**
  24.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  25.  */
  26. class Area extends Model\Document\Editable
  27. {
  28.     /**
  29.      * The Type configured for the area
  30.      *
  31.      * @internal
  32.      *
  33.      * @var string|null
  34.      */
  35.     protected $type;
  36.     /**
  37.      * {@inheritdoc}
  38.      */
  39.     public function getBrickType()
  40.     {
  41.         return $this->type;
  42.     }
  43.     /**
  44.      * {@inheritdoc}
  45.      */
  46.     public function getType()
  47.     {
  48.         return 'area';
  49.     }
  50.     /**
  51.      * {@inheritdoc}
  52.      */
  53.     public function getData()
  54.     {
  55.         return [
  56.             'type' => $this->type,
  57.         ];
  58.     }
  59.     /**
  60.      * {@inheritdoc}
  61.      */
  62.     public function getDataForResource()
  63.     {
  64.         return [
  65.             'type' => $this->type,
  66.         ];
  67.     }
  68.     /**
  69.      * {@inheritdoc}
  70.      */
  71.     public function getDataEditmode() /** : mixed */
  72.     {
  73.         return [
  74.             'type' => $this->type,
  75.         ];
  76.     }
  77.     /**
  78.      * {@inheritdoc}
  79.      */
  80.     public function admin()
  81.     {
  82.         $attributes $this->getEditmodeElementAttributes();
  83.         $attributeString HtmlUtils::assembleAttributeString($attributes);
  84.         $this->outputEditmode('<div ' $attributeString '>');
  85.         $this->frontend();
  86.         $this->outputEditmode('</div>');
  87.     }
  88.     /**
  89.      * @param array $config
  90.      * @param EditableRenderer $editableRenderer
  91.      * @param string $dialogId
  92.      */
  93.     private function renderDialogBoxEditables(array $configEditableRenderer $editableRendererstring $dialogId)
  94.     {
  95.         if (isset($config['items']) && is_array($config['items'])) {
  96.             // layout component
  97.             foreach ($config['items'] as $child) {
  98.                 $this->renderDialogBoxEditables($child$editableRenderer$dialogId);
  99.             }
  100.         } elseif (isset($config['name']) && isset($config['type'])) {
  101.             $editable $editableRenderer->getEditable($this->getDocument(), $config['type'], $config['name'], $config['config'] ?? []);
  102.             if (!$editable instanceof Model\Document\Editable) {
  103.                 throw new \Exception(sprintf('Invalid editable type "%s" configured for Dialog Box'$config['type']));
  104.             }
  105.             $editable->setInDialogBox($dialogId);
  106.             $editable->addConfig('dialogBoxConfig'$config);
  107.             $this->outputEditmode($editable->render());
  108.         } elseif (is_array($config) && isset($config[0])) {
  109.             foreach ($config as $item) {
  110.                 $this->renderDialogBoxEditables($item$editableRenderer$dialogId);
  111.             }
  112.         }
  113.     }
  114.     private function buildInfoObject(): Area\Info
  115.     {
  116.         $config $this->getConfig();
  117.         // create info object and assign it to the view
  118.         $info = new Area\Info();
  119.         $info->setId($config['type']);
  120.         $info->setEditable($this);
  121.         $info->setIndex(0);
  122.         $params = [];
  123.         if (is_array($config['params'][$config['type']] ?? null)) {
  124.             $params $config['params'][$config['type']];
  125.         }
  126.         if (is_array($config['globalParams'] ?? null)) {
  127.             $params array_merge($config['globalParams'], $params);
  128.         }
  129.         $info->setParams($params);
  130.         return $info;
  131.     }
  132.     /**
  133.      * {@inheritdoc}
  134.      */
  135.     public function frontend()
  136.     {
  137.         $config $this->getConfig();
  138.         // TODO inject area handler via DI when editables are built by container
  139.         $editableHandler \Pimcore::getContainer()->get(EditableHandler::class);
  140.         // don't show disabled bricks
  141.         if (!$editableHandler->isBrickEnabled($this$config['type'] && ($config['dontCheckEnabled'] ?? false) !== true)) {
  142.             return;
  143.         }
  144.         // push current block name
  145.         $blockState $this->getBlockState();
  146.         $blockState->pushBlock(BlockName::createFromEditable($this));
  147.         // create info object and assign it to the view
  148.         $info $this->buildInfoObject();
  149.         // start at first index
  150.         $blockState->pushIndex(1);
  151.         $areabrickManager \Pimcore::getContainer()->get(AreabrickManagerInterface::class);
  152.         $dialogConfig null;
  153.         $brick $areabrickManager->getBrick($this->config['type']);
  154.         $info $this->buildInfoObject();
  155.         if ($this->getEditmode() && $brick instanceof EditableDialogBoxInterface) {
  156.             $dialogConfig $brick->getEditableDialogBoxConfiguration($this$info);
  157.             if ($dialogConfig->getItems()) {
  158.                 $dialogConfig->setId('dialogBox-' $this->getName());
  159.             } else {
  160.                 $dialogConfig null;
  161.             }
  162.         }
  163.         if ($dialogConfig) {
  164.             $attributes $this->getEditmodeElementAttributes();
  165.             $dialogAttributes = [
  166.                 'data-dialog-id' => $dialogConfig->getId(),
  167.             ];
  168.             $dialogAttributes HtmlUtils::assembleAttributeString($dialogAttributes);
  169.             $this->outputEditmode('<div class="pimcore_area_dialog" data-name="' $attributes['data-name'] . '" data-real-name="' $attributes['data-real-name'] . '" ' $dialogAttributes '></div>');
  170.         }
  171.         $params = [];
  172.         if (isset($config['params']) && is_array($config['params']) && array_key_exists($config['type'], $config['params'])) {
  173.             if (is_array($config['params'][$config['type']])) {
  174.                 $params $config['params'][$config['type']];
  175.             }
  176.         }
  177.         $info->setParams($params);
  178.         if ($dialogConfig) {
  179.             $editableRenderer \Pimcore::getContainer()->get(EditableRenderer::class);
  180.             $this->outputEditmode('<template id="dialogBoxConfig-' $dialogConfig->getId() . '">' \json_encode($dialogConfig) . '</template>');
  181.             $this->renderDialogBoxEditables($dialogConfig->getItems(), $editableRenderer$dialogConfig->getId());
  182.         }
  183.         echo $editableHandler->renderAreaFrontend($info);
  184.         // remove current block and index from stack
  185.         $blockState->popIndex();
  186.         $blockState->popBlock();
  187.     }
  188.     /**
  189.      * {@inheritdoc}
  190.      */
  191.     public function setDataFromResource($data)
  192.     {
  193.         if (strlen($data) > 2) {
  194.             $data Serialize::unserialize($data);
  195.         }
  196.         $this->type $data['type'] ?? null;
  197.         return $this;
  198.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      */
  202.     public function setDataFromEditmode($data)
  203.     {
  204.         if (is_array($data)) {
  205.             $this->type $data['type'] ?? null;
  206.         }
  207.         return $this;
  208.     }
  209.     /**
  210.      * {@inheritdoc}
  211.      */
  212.     public function isEmpty()
  213.     {
  214.         return false;
  215.     }
  216.     /**
  217.      * Gets an element from the referenced brick. E.g. if you have an area "myArea" which defines "gallery-single-images"
  218.      * as used areabrick and this areabrick defines a block "gallery", you can use $area->getElement('gallery') to get
  219.      * an instance of the block element.
  220.      *
  221.      * @param string $name
  222.      *
  223.      * @return Model\Document\Editable
  224.      */
  225.     public function getElement(string $name)
  226.     {
  227.         $document $this->getDocument();
  228.         $parentBlockNames $this->getParentBlockNames();
  229.         $parentBlockNames[] = $this->getName();
  230.         $id Model\Document\Editable::buildChildEditableName($name'area'$parentBlockNames1);
  231.         $editable $document->getEditable($id);
  232.         if ($editable) {
  233.             $editable->setParentBlockNames($parentBlockNames);
  234.         }
  235.         return $editable;
  236.     }
  237. }