vendor/sulu/sulu/src/Sulu/Component/Content/Compat/Property.php line 20

  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;
  14. use Sulu\Component\Content\Document\Structure\PropertyValue;
  15. use Sulu\Component\Util\ArrayableInterface;
  17. /**
  18.  * Property of Structure generated from Structure Manager to map a template.
  19.  */
  20. class Property implements PropertyInterface, \JsonSerializable
  21. {
  22.     /**
  23.      * @var Metadata
  24.      */
  25.     private $metadata;
  27.     /**
  28.      * @var mixed
  29.      */
  30.     private $value;
  32.     /**
  33.      * @var StructureInterface
  34.      */
  35.     private $structure;
  37.     /**
  38.      * @var PropertyValue
  39.      */
  40.     protected $propertyValue;
  42.     /**
  43.      * properties managed by this block.
  44.      *
  45.      * @var PropertyType[]
  46.      */
  47.     protected $types = [];
  49.     /**
  50.      * @var PropertyType[]
  51.      */
  52.     protected $properties = [];
  54.     /**
  55.      * @param string $name
  56.      * @param array<string, mixed>|string $metaData
  57.      * @param bool $mandatory
  58.      * @param bool $multilingual
  59.      * @param int|null $minOccurs
  60.      * @param int|null $maxOccurs
  61.      * @param string $contentTypeName
  62.      * @param mixed[] $params
  63.      * @param \Sulu\Component\Content\Compat\PropertyTag[] $tags
  64.      * @param int $colSpan
  65.      * @param string|null $defaultTypeName
  66.      */
  67.     public function __construct(
  68.         private $name,
  69.         $metaData,
  70.         private $contentTypeName,
  71.         private $mandatory = false,
  72.         private $multilingual = true,
  73.         private $maxOccurs = 1,
  74.         private $minOccurs = 1,
  75.         private $params = [],
  76.         private $tags = [],
  77.         private $colSpan = null,
  78.         protected $defaultTypeName = null
  79.     ) {
  80.         $this->metadata = new Metadata($metaData);
  81.     }
  83.     public function setPropertyValue(PropertyValue $propertyValue)
  84.     {
  85.         $this->propertyValue = $propertyValue;
  86.     }
  88.     /**
  89.      * returns name of template.
  90.      *
  91.      * @return string
  92.      */
  93.     public function getName()
  94.     {
  95.         return $this->name;
  96.     }
  98.     /**
  99.      * returns mandatory.
  100.      *
  101.      * @return bool
  102.      */
  103.     public function isMandatory()
  104.     {
  105.         return $this->mandatory;
  106.     }
  108.     /**
  109.      * returns multilingual.
  110.      *
  111.      * @return bool
  112.      */
  113.     public function isMultilingual()
  114.     {
  115.         return $this->multilingual;
  116.     }
  118.     /**
  119.      * return min occurs.
  120.      *
  121.      * @return int|null
  122.      */
  123.     public function getMinOccurs()
  124.     {
  125.         return $this->minOccurs;
  126.     }
  128.     /**
  129.      * return max occurs.
  130.      *
  131.      * @return int|null
  132.      */
  133.     public function getMaxOccurs()
  134.     {
  135.         return $this->maxOccurs;
  136.     }
  138.     /**
  139.      * returns field is mandatory.
  140.      *
  141.      * @return bool
  142.      */
  143.     public function getMandatory()
  144.     {
  145.         return $this->mandatory;
  146.     }
  148.     /**
  149.      * returns field is multilingual.
  150.      *
  151.      * @return bool
  152.      */
  153.     public function getMultilingual()
  154.     {
  155.         return $this->multilingual;
  156.     }
  158.     /**
  159.      * returns tags defined in xml.
  160.      *
  161.      * @return PropertyTag[]
  162.      */
  163.     public function getTags()
  164.     {
  165.         return $this->tags;
  166.     }
  168.     /**
  169.      * returns tag with given name.
  170.      *
  171.      * @param string $tagName
  172.      *
  173.      * @return PropertyTag
  174.      */
  175.     public function getTag($tagName)
  176.     {
  177.         return $this->tags[$tagName];
  178.     }
  180.     /**
  181.      * add a property tag.
  182.      *
  183.      * @return PropertyTag
  184.      */
  185.     public function addTag(PropertyTag $tag)
  186.     {
  187.         return $this->tags[$tag->getName()] = $tag;
  188.     }
  190.     /**
  191.      * return true if a tag with the given name exists.
  192.      *
  193.      * @return bool
  194.      */
  195.     public function hasTag($tagName)
  196.     {
  197.         return isset($this->tags[$tagName]);
  198.     }
  200.     /**
  201.      * returns column span.
  202.      *
  203.      * @return int
  204.      */
  205.     public function getColSpan()
  206.     {
  207.         return $this->colSpan;
  208.     }
  210.     /**
  211.      * returns title of property.
  212.      *
  213.      * @param string $languageCode
  214.      *
  215.      * @return string
  216.      */
  217.     public function getTitle($languageCode)
  218.     {
  219.         return $this->metadata->get('title', $languageCode, \ucfirst($this->name));
  220.     }
  222.     /**
  223.      * returns infoText of property.
  224.      *
  225.      * @param string $languageCode
  226.      *
  227.      * @return string
  228.      */
  229.     public function getInfoText($languageCode)
  230.     {
  231.         return $this->metadata->get('info_text', $languageCode, '');
  232.     }
  234.     /**
  235.      * returns placeholder of property.
  236.      *
  237.      * @param string $languageCode
  238.      *
  239.      * @return string
  240.      */
  241.     public function getPlaceholder($languageCode)
  242.     {
  243.         return $this->metadata->get('placeholder', $languageCode, '');
  244.     }
  246.     /**
  247.      * sets the value from property.
  248.      */
  249.     public function setValue($value)
  250.     {
  251.         if ($this->propertyValue) {
  252.             $this->propertyValue->setValue($value);
  253.         }
  255.         $this->value = $value;
  256.     }
  258.     public function setValueByReference(&$value)
  259.     {
  260.         $this->value = $value;
  261.     }
  263.     /**
  264.      * gets the value from property.
  265.      */
  266.     public function getValue()
  267.     {
  268.         if ($this->propertyValue) {
  269.             return $this->propertyValue->getValue();
  270.         }
  272.         return $this->value;
  273.     }
  275.     /**
  276.      * returns name of content type.
  277.      *
  278.      * @return string
  279.      */
  280.     public function getContentTypeName()
  281.     {
  282.         return $this->contentTypeName;
  283.     }
  285.     /**
  286.      * parameter of property.
  287.      *
  288.      * @return array
  289.      */
  290.     public function getParams()
  291.     {
  292.         return $this->params;
  293.     }
  295.     /**
  296.      * returns TRUE if property is a block.
  297.      *
  298.      * @return bool
  299.      */
  300.     public function getIsBlock()
  301.     {
  302.         return false;
  303.     }
  305.     /**
  306.      * returns TRUE if property is multiple.
  307.      *
  308.      * @return bool
  309.      */
  310.     public function getIsMultiple()
  311.     {
  312.         $minOccurs = $this->getMinOccurs();
  313.         $maxOccurs = $this->getMaxOccurs();
  315.         if (\is_null($minOccurs) && \is_null($maxOccurs)) {
  316.             // if no occurs attributes are set it defaults to false
  317.             return false;
  318.         }
  320.         if (0 === $minOccurs && 1 === $maxOccurs) {
  321.             // this one allows to have an optional field
  322.             return true;
  323.         }
  325.         if (1 === $minOccurs && 1 === $maxOccurs) {
  326.             // if the occurences have a high and low limit of 1 it should be displayed as single
  327.             return false;
  328.         }
  330.         // if minOccurs is set a value of 1 is enough, because maxOccurs would be considered "unbound" when null
  331.         return $minOccurs >= 1 || $maxOccurs > 1;
  332.     }
  334.     /**
  335.      * @return Metadata
  336.      */
  337.     public function getMetadata()
  338.     {
  339.         return $this->metadata;
  340.     }
  342.     /**
  343.      * returns structure.
  344.      *
  345.      * @return StructureInterface
  346.      */
  347.     public function getStructure()
  348.     {
  349.         return $this->structure;
  350.     }
  352.     /**
  353.      * @param StructureInterface $structure
  354.      */
  355.     public function setStructure($structure)
  356.     {
  357.         $this->structure = $structure;
  358.     }
  360.     /**
  361.      * magic getter for twig templates.
  362.      *
  363.      * @param string $property
  364.      */
  365.     public function __get($property)
  366.     {
  367.         if (\method_exists($this, 'get' . \ucfirst($property))) {
  368.             return $this->{'get' . \ucfirst($property)}();
  369.         } else {
  370.             return;
  371.         }
  372.     }
  374.     #[\ReturnTypeWillChange]
  375.     public function jsonSerialize()
  376.     {
  377.         $result = [
  378.             'name' => $this->getName(),
  379.             'metadata' => $this->getMetadata()->getData(),
  380.             'mandatory' => $this->getMandatory(),
  381.             'multilingual' => $this->getMultilingual(),
  382.             'minOccurs' => $this->getMinOccurs(),
  383.             'maxOccurs' => $this->getMaxOccurs(),
  384.             'contentTypeName' => $this->getContentTypeName(),
  385.             'params' => $this->getParams(),
  386.             'tags' => [],
  387.         ];
  388.         foreach ($this->getTags() as $tag) {
  389.             $result['tags'][] = [
  390.                 'name' => $tag->getName(),
  391.                 'priority' => $tag->getPriority(),
  392.             ];
  393.         }
  395.         return $result;
  396.     }
  398.     public function __clone()
  399.     {
  400.         $clone = new self(
  401.             $this->getName(),
  402.             $this->getMetadata(),
  403.             $this->getContentTypeName(),
  404.             $this->getMandatory(),
  405.             $this->getMultilingual(),
  406.             $this->getMaxOccurs(),
  407.             $this->getMinOccurs(),
  408.             $this->getParams(),
  409.             $this->getTags(),
  410.             $this->getColSpan(),
  411.             $this->getDefaultTypeName()
  412.         );
  414.         $clone->types = [];
  415.         foreach ($this->types as $type) {
  416.             $clone->addType(clone $type);
  417.         }
  419.         $clone->setValue($this->getValue());
  421.         return $clone;
  422.     }
  424.     public function toArray($depth = null)
  425.     {
  426.         if ($this->getValue() instanceof ArrayableInterface) {
  427.             return $this->getValue()->toArray($depth);
  428.         } else {
  429.             return $this->getValue();
  430.         }
  431.     }
  433.     public function getTypes()
  434.     {
  435.         return $this->types;
  436.     }
  438.     public function addType($type)
  439.     {
  440.         $this->types[$type->getName()] = $type;
  441.     }
  443.     public function getType($name)
  444.     {
  445.         if (!$this->hasType($name)) {
  446.             throw new \InvalidArgumentException(
  447.                 \sprintf(
  448.                     'The block type "%s" has not been registered. Known block types are: [%s]',
  449.                     $name,
  450.                     \implode(', ', \array_keys($this->types))
  451.                 )
  452.             );
  453.         }
  455.         return $this->types[$name];
  456.     }
  458.     public function hasType($name)
  459.     {
  460.         return isset($this->types[$name]);
  461.     }
  463.     public function getDefaultTypeName()
  464.     {
  465.         return $this->defaultTypeName;
  466.     }
  468.     /**
  469.      * returns child properties of given Type.
  470.      *
  471.      * @param string $typeName
  472.      *
  473.      * @return PropertyInterface[]
  474.      */
  475.     public function getTypeChildProperties($typeName)
  476.     {
  477.         return $this->getType($typeName)->getChildProperties();
  478.     }
  480.     public function initProperties($index, $typeName)
  481.     {
  482.         $type = $this->getType($typeName);
  483.         $this->properties[$index] = clone $type;
  485.         return $this->properties[$index];
  486.     }
  488.     public function clearProperties()
  489.     {
  490.         $this->properties = [];
  491.     }
  493.     public function getProperties($index)
  494.     {
  495.         if (!isset($this->properties[$index])) {
  496.             throw new \OutOfRangeException(\sprintf(
  497.                 'No properties at index "%s" in block "%s". Valid indexes: [%s]',
  498.                 $index, $this->getName(), \implode(', ', \array_keys($this->properties))
  499.             ));
  500.         }
  502.         return $this->properties[$index];
  503.     }
  505.     public function getLength()
  506.     {
  507.         return \count($this->properties);
  508.     }
  509. }