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.      * name of property.
  24.      *
  25.      * @var string
  26.      */
  27.     private $name;
  29.     /**
  30.      * @var Metadata
  31.      */
  32.     private $metadata;
  34.     /**
  35.      * is property mandatory.
  36.      *
  37.      * @var bool
  38.      */
  39.     private $mandatory;
  41.     /**
  42.      * is property multilingual.
  43.      *
  44.      * @var bool
  45.      */
  46.     private $multilingual;
  48.     /**
  49.      * min occurs of property value.
  50.      *
  51.      * @var int
  52.      */
  53.     private $minOccurs;
  55.     /**
  56.      * max occurs of property value.
  57.      *
  58.      * @var int
  59.      */
  60.     private $maxOccurs;
  62.     /**
  63.      * name of content type.
  64.      *
  65.      * @var string
  66.      */
  67.     private $contentTypeName;
  69.     /**
  70.      * parameter of property to merge with parameter of content type.
  71.      *
  72.      * @var array
  73.      */
  74.     private $params;
  76.     /**
  77.      * tags defined in xml.
  78.      *
  79.      * @var PropertyTag[]
  80.      */
  81.     private $tags;
  83.     /**
  84.      * column span.
  85.      *
  86.      * @var string
  87.      */
  88.     private $colSpan;
  90.     /**
  91.      * value of property.
  92.      *
  93.      * @var mixed
  94.      */
  95.     private $value;
  97.     /**
  98.      * @var StructureInterface
  99.      */
  100.     private $structure;
  102.     /**
  103.      * Constructor.
  104.      *
  105.      * @var PropertyValue
  106.      */
  107.     protected $propertyValue;
  109.     /**
  110.      * properties managed by this block.
  111.      *
  112.      * @var PropertyType[]
  113.      */
  114.     protected $types = [];
  116.     /**
  117.      * @var PropertyType[]
  118.      */
  119.     protected $properties = [];
  121.     /**
  122.      * @var string|null
  123.      */
  124.     protected $defaultTypeName;
  126.     public function __construct(
  127.         $name,
  128.         $metaData,
  129.         $contentTypeName,
  130.         $mandatory = false,
  131.         $multilingual = true,
  132.         $maxOccurs = 1,
  133.         $minOccurs = 1,
  134.         $params = [],
  135.         $tags = [],
  136.         $colSpan = null,
  137.         $defaultTypeName = null
  138.     ) {
  139.         $this->contentTypeName = $contentTypeName;
  140.         $this->mandatory = $mandatory;
  141.         $this->maxOccurs = $maxOccurs;
  142.         $this->minOccurs = $minOccurs;
  143.         $this->multilingual = $multilingual;
  144.         $this->name = $name;
  145.         $this->metadata = new Metadata($metaData);
  146.         $this->params = $params;
  147.         $this->tags = $tags;
  148.         $this->colSpan = $colSpan;
  149.         $this->defaultTypeName = $defaultTypeName;
  150.     }
  152.     public function setPropertyValue(PropertyValue $propertyValue)
  153.     {
  154.         $this->propertyValue = $propertyValue;
  155.     }
  157.     /**
  158.      * returns name of template.
  159.      *
  160.      * @return string
  161.      */
  162.     public function getName()
  163.     {
  164.         return $this->name;
  165.     }
  167.     /**
  168.      * returns mandatory.
  169.      *
  170.      * @return bool
  171.      */
  172.     public function isMandatory()
  173.     {
  174.         return $this->mandatory;
  175.     }
  177.     /**
  178.      * returns multilingual.
  179.      *
  180.      * @return bool
  181.      */
  182.     public function isMultilingual()
  183.     {
  184.         return $this->multilingual;
  185.     }
  187.     /**
  188.      * return min occurs.
  189.      *
  190.      * @return int
  191.      */
  192.     public function getMinOccurs()
  193.     {
  194.         return $this->minOccurs;
  195.     }
  197.     /**
  198.      * return max occurs.
  199.      *
  200.      * @return int
  201.      */
  202.     public function getMaxOccurs()
  203.     {
  204.         return $this->maxOccurs;
  205.     }
  207.     /**
  208.      * returns field is mandatory.
  209.      *
  210.      * @return bool
  211.      */
  212.     public function getMandatory()
  213.     {
  214.         return $this->mandatory;
  215.     }
  217.     /**
  218.      * returns field is multilingual.
  219.      *
  220.      * @return bool
  221.      */
  222.     public function getMultilingual()
  223.     {
  224.         return $this->multilingual;
  225.     }
  227.     /**
  228.      * returns tags defined in xml.
  229.      *
  230.      * @return PropertyTag[]
  231.      */
  232.     public function getTags()
  233.     {
  234.         return $this->tags;
  235.     }
  237.     /**
  238.      * returns tag with given name.
  239.      *
  240.      * @param string $tagName
  241.      *
  242.      * @return PropertyTag
  243.      */
  244.     public function getTag($tagName)
  245.     {
  246.         return $this->tags[$tagName];
  247.     }
  249.     /**
  250.      * add a property tag.
  251.      *
  252.      * @return PropertyTag
  253.      */
  254.     public function addTag(PropertyTag $tag)
  255.     {
  256.         return $this->tags[$tag->getName()] = $tag;
  257.     }
  259.     /**
  260.      * return true if a tag with the given name exists.
  261.      *
  262.      * @return bool
  263.      */
  264.     public function hasTag($tagName)
  265.     {
  266.         return isset($this->tags[$tagName]);
  267.     }
  269.     /**
  270.      * returns column span.
  271.      *
  272.      * @return string
  273.      */
  274.     public function getColSpan()
  275.     {
  276.         return $this->colSpan;
  277.     }
  279.     /**
  280.      * returns title of property.
  281.      *
  282.      * @param string $languageCode
  283.      *
  284.      * @return string
  285.      */
  286.     public function getTitle($languageCode)
  287.     {
  288.         return $this->metadata->get('title', $languageCode, \ucfirst($this->name));
  289.     }
  291.     /**
  292.      * returns infoText of property.
  293.      *
  294.      * @param string $languageCode
  295.      *
  296.      * @return string
  297.      */
  298.     public function getInfoText($languageCode)
  299.     {
  300.         return $this->metadata->get('info_text', $languageCode, '');
  301.     }
  303.     /**
  304.      * returns placeholder of property.
  305.      *
  306.      * @param string $languageCode
  307.      *
  308.      * @return string
  309.      */
  310.     public function getPlaceholder($languageCode)
  311.     {
  312.         return $this->metadata->get('placeholder', $languageCode, '');
  313.     }
  315.     /**
  316.      * sets the value from property.
  317.      */
  318.     public function setValue($value)
  319.     {
  320.         if ($this->propertyValue) {
  321.             $this->propertyValue->setValue($value);
  322.         }
  324.         $this->value = $value;
  325.     }
  327.     public function setValueByReference(&$value)
  328.     {
  329.         $this->value = $value;
  330.     }
  332.     /**
  333.      * gets the value from property.
  334.      */
  335.     public function getValue()
  336.     {
  337.         if ($this->propertyValue) {
  338.             return $this->propertyValue->getValue();
  339.         }
  341.         return $this->value;
  342.     }
  344.     /**
  345.      * returns name of content type.
  346.      *
  347.      * @return string
  348.      */
  349.     public function getContentTypeName()
  350.     {
  351.         return $this->contentTypeName;
  352.     }
  354.     /**
  355.      * parameter of property.
  356.      *
  357.      * @return array
  358.      */
  359.     public function getParams()
  360.     {
  361.         return $this->params;
  362.     }
  364.     /**
  365.      * returns TRUE if property is a block.
  366.      *
  367.      * @return bool
  368.      */
  369.     public function getIsBlock()
  370.     {
  371.         return false;
  372.     }
  374.     /**
  375.      * returns TRUE if property is multiple.
  376.      *
  377.      * @return bool
  378.      */
  379.     public function getIsMultiple()
  380.     {
  381.         $minOccurs = $this->getMinOccurs();
  382.         $maxOccurs = $this->getMaxOccurs();
  384.         if (\is_null($minOccurs) && \is_null($maxOccurs)) {
  385.             // if no occurs attributes are set it defaults to false
  386.             return false;
  387.         }
  389.         if (0 === $minOccurs && 1 === $maxOccurs) {
  390.             // this one allows to have an optional field
  391.             return true;
  392.         }
  394.         if (1 === $minOccurs && 1 === $maxOccurs) {
  395.             // if the occurences have a high and low limit of 1 it should be displayed as single
  396.             return false;
  397.         }
  399.         // if minOccurs is set a value of 1 is enough, because maxOccurs would be considered "unbound" when null
  400.         return $minOccurs >= 1 || $maxOccurs > 1;
  401.     }
  403.     /**
  404.      * @return Metadata
  405.      */
  406.     public function getMetadata()
  407.     {
  408.         return $this->metadata;
  409.     }
  411.     /**
  412.      * returns structure.
  413.      *
  414.      * @return StructureInterface
  415.      */
  416.     public function getStructure()
  417.     {
  418.         return $this->structure;
  419.     }
  421.     /**
  422.      * @param StructureInterface $structure
  423.      */
  424.     public function setStructure($structure)
  425.     {
  426.         $this->structure = $structure;
  427.     }
  429.     /**
  430.      * magic getter for twig templates.
  431.      *
  432.      * @param string $property
  433.      */
  434.     public function __get($property)
  435.     {
  436.         if (\method_exists($this, 'get' . \ucfirst($property))) {
  437.             return $this->{'get' . \ucfirst($property)}();
  438.         } else {
  439.             return;
  440.         }
  441.     }
  443.     #[\ReturnTypeWillChange]
  444.     public function jsonSerialize()
  445.     {
  446.         $result = [
  447.             'name' => $this->getName(),
  448.             'metadata' => $this->getMetadata()->getData(),
  449.             'mandatory' => $this->getMandatory(),
  450.             'multilingual' => $this->getMultilingual(),
  451.             'minOccurs' => $this->getMinOccurs(),
  452.             'maxOccurs' => $this->getMaxOccurs(),
  453.             'contentTypeName' => $this->getContentTypeName(),
  454.             'params' => $this->getParams(),
  455.             'tags' => [],
  456.         ];
  457.         foreach ($this->getTags() as $tag) {
  458.             $result['tags'][] = [
  459.                 'name' => $tag->getName(),
  460.                 'priority' => $tag->getPriority(),
  461.             ];
  462.         }
  464.         return $result;
  465.     }
  467.     public function __clone()
  468.     {
  469.         $clone = new self(
  470.             $this->getName(),
  471.             $this->getMetadata(),
  472.             $this->getContentTypeName(),
  473.             $this->getMandatory(),
  474.             $this->getMultilingual(),
  475.             $this->getMaxOccurs(),
  476.             $this->getMinOccurs(),
  477.             $this->getParams(),
  478.             $this->getTags(),
  479.             $this->getColSpan(),
  480.             $this->getDefaultTypeName()
  481.         );
  483.         $clone->types = [];
  484.         foreach ($this->types as $type) {
  485.             $clone->addType(clone $type);
  486.         }
  488.         $clone->setValue($this->getValue());
  490.         return $clone;
  491.     }
  493.     public function toArray($depth = null)
  494.     {
  495.         if ($this->getValue() instanceof ArrayableInterface) {
  496.             return $this->getValue()->toArray($depth);
  497.         } else {
  498.             return $this->getValue();
  499.         }
  500.     }
  502.     public function getTypes()
  503.     {
  504.         return $this->types;
  505.     }
  507.     public function addType($type)
  508.     {
  509.         $this->types[$type->getName()] = $type;
  510.     }
  512.     public function getType($name)
  513.     {
  514.         if (!$this->hasType($name)) {
  515.             throw new \InvalidArgumentException(
  516.                 \sprintf(
  517.                     'The block type "%s" has not been registered. Known block types are: [%s]',
  518.                     $name,
  519.                     \implode(', ', \array_keys($this->types))
  520.                 )
  521.             );
  522.         }
  524.         return $this->types[$name];
  525.     }
  527.     public function hasType($name)
  528.     {
  529.         return isset($this->types[$name]);
  530.     }
  532.     public function getDefaultTypeName()
  533.     {
  534.         return $this->defaultTypeName;
  535.     }
  537.     /**
  538.      * returns child properties of given Type.
  539.      *
  540.      * @param string $typeName
  541.      *
  542.      * @return PropertyInterface[]
  543.      */
  544.     public function getTypeChildProperties($typeName)
  545.     {
  546.         return $this->getType($typeName)->getChildProperties();
  547.     }
  549.     public function initProperties($index, $typeName)
  550.     {
  551.         $type = $this->getType($typeName);
  552.         $this->properties[$index] = clone $type;
  554.         return $this->properties[$index];
  555.     }
  557.     public function clearProperties()
  558.     {
  559.         $this->properties = [];
  560.     }
  562.     public function getProperties($index)
  563.     {
  564.         if (!isset($this->properties[$index])) {
  565.             throw new \OutOfRangeException(\sprintf(
  566.                 'No properties at index "%s" in block "%s". Valid indexes: [%s]',
  567.                 $index, $this->getName(), \implode(', ', \array_keys($this->properties))
  568.             ));
  569.         }
  571.         return $this->properties[$index];
  572.     }
  574.     public function getLength()
  575.     {
  576.         return \count($this->properties);
  577.     }
  578. }