vendor/sulu/sulu/src/Sulu/Component/Content/Compat/Block/BlockProperty.php line 27

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Component\Content\Compat\Block;
  14. use Sulu\Component\Content\Compat\Property;
  15. use Sulu\Component\Content\Compat\PropertyInterface;
  16. use Sulu\Component\Content\Document\Structure\PropertyValue;
  18. /**
  19.  * Representation of a block node in template xml.
  20.  *
  21.  * @method BlockPropertyType[] getTypes()
  22.  * @method addType(BlockPropertyType $type)
  23.  * @method BlockPropertyType getType(string $name)
  24.  * @method BlockPropertyType getProperties(int $index)
  25.  * @method BlockPropertyType initProperties(int $index, string $typeName)
  26.  */
  27. class BlockProperty extends Property implements BlockPropertyInterface
  28. {
  29.     public function __construct(
  30.         $name,
  31.         $metadata,
  32.         $defaultTypeName,
  33.         $mandatory = false,
  34.         $multilingual = false,
  35.         $maxOccurs = 1,
  36.         $minOccurs = 1,
  37.         $params = [],
  38.         $tags = [],
  39.         $col = null
  40.     ) {
  41.         parent::__construct(
  42.             $name,
  43.             $metadata,
  44.             'block',
  45.             $mandatory,
  46.             $multilingual,
  47.             $maxOccurs,
  48.             $minOccurs,
  49.             $params,
  50.             $tags,
  51.             $col,
  52.             $defaultTypeName
  53.         );
  54.     }
  56.     public function setValue($value)
  57.     {
  58.         $this->doSetValue($value);
  60.         if ($this->propertyValue) {
  61.             $this->propertyValue->setValue($value);
  62.         }
  63.     }
  65.     public function setPropertyValue(PropertyValue $value)
  66.     {
  67.         parent::setPropertyValue($value);
  68.         $this->doSetValue($value);
  69.     }
  71.     /**
  72.      * Sub properties need to be referenced to the PropertyValue so
  73.      * that the "real" property is updated.
  74.      *
  75.      * TODO: This is very tedious code. It is important to factor this out.
  76.      *
  77.      * @param array|PropertyValue|null $value
  78.      */
  79.     public function doSetValue($value)
  80.     {
  81.         $items = $value;
  82.         if ($value instanceof PropertyValue) {
  83.             $items = $value->getValue();
  84.         }
  86.         if (null == $items) {
  87.             return;
  88.         }
  90.         if (!\is_array($items)) {
  91.             throw new \InvalidArgumentException(
  92.                 \sprintf('Expected block configuration but got "%s" at property: "%s"', \get_debug_type($items), $this->getName())
  93.             );
  94.         }
  96.         // check value for single value
  97.         if (\array_keys($items) !== \range(0, \count($items) - 1)) {
  98.             $items = [$items];
  99.         }
  101.         $this->properties = [];
  103.         for ($i = 0; $i < \count($items); ++$i) {
  104.             $item = $items[$i];
  105.             $type = $this->initProperties($i, $item['type']);
  106.             if (isset($item['settings'])) {
  107.                 $type->setSettings($item['settings']);
  108.             }
  110.             /** @var PropertyInterface $subProperty */
  111.             foreach ($type->getChildProperties() as $subProperty) {
  112.                 if (!isset($item[$subProperty->getName()])) {
  113.                     continue;
  114.                 }
  116.                 $subName = $subProperty->getName();
  117.                 $subValue = $item[$subName];
  119.                 if ($subValue instanceof PropertyValue) {
  120.                     $subValueProperty = new PropertyValue($subName, $subValue);
  121.                     $subProperty->setPropertyValue($subValueProperty);
  122.                     $item[$subName] = $subValueProperty;
  123.                 } else {
  124.                     $subProperty->setValue($subValue);
  125.                 }
  126.             }
  128.             $items[$i] = $item;
  129.         }
  131.         if ($value instanceof PropertyValue) {
  132.             $value->setValue($items);
  133.         }
  134.     }
  136.     /**
  137.      * get value of sub properties.
  138.      *
  139.      * @return array|mixed
  140.      */
  141.     public function getValue()
  142.     {
  143.         // if size of children smaller than minimum
  144.         if (\count($this->properties) < $this->getMinOccurs()) {
  145.             for ($i = \count($this->properties); $i < $this->getMinOccurs(); ++$i) {
  146.                 $this->initProperties($i, $this->getDefaultTypeName());
  147.             }
  148.         }
  150.         $data = [];
  151.         foreach ($this->properties as $type) {
  152.             $result = [
  153.                 'type' => $type->getName(),
  154.                 'settings' => $type->getSettings(),
  155.             ];
  156.             foreach ($type->getChildProperties() as $property) {
  157.                 $result[$property->getName()] = $property->getValue();
  158.             }
  159.             $data[] = $result;
  160.         }
  162.         return $data;
  163.     }
  165.     /**
  166.      * returns TRUE if property is a block.
  167.      *
  168.      * @return bool
  169.      */
  170.     public function getIsBlock()
  171.     {
  172.         return true;
  173.     }
  175.     public function getIsMultiple()
  176.     {
  177.         if (\is_null($this->getMinOccurs()) || \is_null($this->getMaxOccurs())) {
  178.             // in contrast to properties blocks are multiple by default
  179.             return true;
  180.         }
  182.         return parent::getIsMultiple();
  183.     }
  185.     /**
  186.      * returns child properties of given Type.
  187.      *
  188.      * @param string $typeName
  189.      *
  190.      * @return PropertyInterface[]
  191.      */
  192.     public function getChildProperties($typeName)
  193.     {
  194.         return $this->getTypeChildProperties($typeName);
  195.     }
  196. }