vendor/sulu/sulu/src/Sulu/Component/Content/Compat/Structure/StructureBridge.php line 664

  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\Structure;
  14. use Sulu\Bundle\DocumentManagerBundle\Bridge\DocumentInspector;
  15. use Sulu\Component\Content\Compat\StructureInterface;
  16. use Sulu\Component\Content\Compat\StructureType;
  17. use Sulu\Component\Content\Document\Behavior\ExtensionBehavior;
  18. use Sulu\Component\Content\Document\Behavior\NavigationContextBehavior;
  19. use Sulu\Component\Content\Document\Behavior\OrderBehavior;
  20. use Sulu\Component\Content\Document\Behavior\RedirectTypeBehavior;
  21. use Sulu\Component\Content\Document\Behavior\ResourceSegmentBehavior;
  22. use Sulu\Component\Content\Document\Behavior\ShadowLocaleBehavior;
  23. use Sulu\Component\Content\Document\Behavior\StructureBehavior;
  24. use Sulu\Component\Content\Document\Behavior\WorkflowStageBehavior;
  25. use Sulu\Component\Content\Document\LocalizationState;
  26. use Sulu\Component\Content\Document\RedirectType;
  27. use Sulu\Component\Content\Document\WorkflowStage;
  28. use Sulu\Component\Content\Metadata\StructureMetadata;
  30. /**
  31.  * @deprecated Should be replaced by a proper StructureInterface implementation
  32.  */
  33. class StructureBridge implements StructureInterface
  34. {
  35.     /**
  36.      * @var StructureMetadata
  37.      */
  38.     protected $structure;
  40.     /**
  41.      * @var object
  42.      */
  43.     protected $document;
  45.     /**
  46.      * @var DocumentInspector
  47.      */
  48.     protected $inspector;
  50.     /**
  51.      * @var LegacyPropertyFactory
  52.      */
  53.     private $propertyFactory;
  55.     /**
  56.      * @var array
  57.      */
  58.     private $loadedProperties = [];
  60.     /**
  61.      * Needed by structure extensions when the document has not been set..
  62.      *
  63.      * @var string
  64.      */
  65.     protected $locale;
  67.     /**
  68.      * @param object $document
  69.      */
  70.     public function __construct(
  71.         StructureMetadata $structure,
  72.         DocumentInspector $inspector,
  73.         LegacyPropertyFactory $propertyFactory,
  74.         $document = null
  75.     ) {
  76.         $this->structure = $structure;
  77.         $this->inspector = $inspector;
  78.         $this->propertyFactory = $propertyFactory;
  79.         $this->document = $document;
  80.     }
  82.     public function setDocument(StructureBehavior $document)
  83.     {
  84.         $this->document = $document;
  85.     }
  87.     public function setLanguageCode($locale)
  88.     {
  89.         $this->locale = $locale;
  90.     }
  92.     public function getLanguageCode()
  93.     {
  94.         if (!$this->document) {
  95.             return $this->locale;
  96.         }
  98.         return $this->inspector->getLocale($this->getDocument());
  99.     }
  101.     public function setWebspaceKey($webspace)
  102.     {
  103.         $this->readOnlyException(__METHOD__);
  104.     }
  106.     public function getWebspaceKey()
  107.     {
  108.         if (!$this->document) {
  109.             return null;
  110.         }
  112.         return $this->inspector->getWebspace($this->getDocument());
  113.     }
  115.     public function getUuid()
  116.     {
  117.         return $this->getDocument()->getUuid();
  118.     }
  120.     public function setUuid($uuid)
  121.     {
  122.         $this->readOnlyException(__METHOD__);
  123.     }
  125.     public function getCreator()
  126.     {
  127.         return $this->getDocument()->getCreator();
  128.     }
  130.     public function setCreator($userId)
  131.     {
  132.         $this->readOnlyException(__METHOD__);
  133.     }
  135.     public function getChanger()
  136.     {
  137.         return $this->getDocument()->getChanger();
  138.     }
  140.     public function setChanger($userId)
  141.     {
  142.         $this->readOnlyException(__METHOD__);
  143.     }
  145.     public function getCreated()
  146.     {
  147.         return $this->getDocument()->getCreated();
  148.     }
  150.     public function setCreated(\DateTime $created)
  151.     {
  152.         $this->readOnlyException(__METHOD__);
  153.     }
  155.     public function getChanged()
  156.     {
  157.         return $this->getDocument()->getChanged();
  158.     }
  160.     public function setChanged(\DateTime $changed)
  161.     {
  162.         $this->readOnlyException(__METHOD__);
  163.     }
  165.     public function getKey()
  166.     {
  167.         return $this->structure->getName();
  168.     }
  170.     public function getInternal()
  171.     {
  172.         return $this->structure->isInternal();
  173.     }
  175.     public function getProperty($name)
  176.     {
  177.         if ($this->hasProperty($name)) {
  178.             $property = $this->structure->getProperty($name);
  179.         } else {
  180.             $property = $this->structure->getChild($name);
  181.         }
  183.         return $this->createLegacyPropertyFromItem($property);
  184.     }
  186.     public function hasProperty($name)
  187.     {
  188.         return $this->structure->hasProperty($name);
  189.     }
  191.     public function getProperties($flatten = false)
  192.     {
  193.         if ($flatten) {
  194.             $items = $this->structure->getProperties();
  195.         } else {
  196.             $items = $this->structure->getChildren();
  197.         }
  199.         $propertyBridges = [];
  200.         foreach ($items as $property) {
  201.             $propertyBridges[$property->getName()] = $this->createLegacyPropertyFromItem($property);
  202.         }
  204.         return $propertyBridges;
  205.     }
  207.     public function getExt()
  208.     {
  209.         return $this->document->getExtensionsData();
  210.     }
  212.     public function setExt($data)
  213.     {
  214.         $this->readOnlyException(__METHOD__);
  215.     }
  217.     public function setHasChildren($hasChildren)
  218.     {
  219.         $this->readOnlyException(__METHOD__);
  220.     }
  222.     public function getHasChildren()
  223.     {
  224.         return $this->inspector->hasChildren($this->getDocument());
  225.     }
  227.     public function setChildren($children)
  228.     {
  229.         $this->readOnlyException(__METHOD__);
  230.     }
  232.     public function getChildren()
  233.     {
  234.         $children = [];
  236.         foreach ($this->getDocument()->getChildren() as $child) {
  237.             $children[] = $this->documentToStructure($child);
  238.         }
  240.         return $children;
  241.     }
  243.     /**
  244.      * @return $this
  245.      */
  246.     public function getParent()
  247.     {
  248.         return $this->documentToStructure($this->inspector->getParent($this->getDocument()));
  249.     }
  251.     public function getPublishedState()
  252.     {
  253.         return WorkflowStage::PUBLISHED === $this->getWorkflowDocument(__METHOD__)->getWorkflowStage();
  254.     }
  256.     public function setPublished($published)
  257.     {
  258.         $this->readOnlyException(__METHOD__);
  259.     }
  261.     public function getPublished()
  262.     {
  263.         return $this->getWorkflowDocument(__METHOD__)->getPublished();
  264.     }
  266.     public function getPropertyValue($name)
  267.     {
  268.         return $this->getProperty($name)->getValue();
  269.     }
  271.     public function getPropertyNames()
  272.     {
  273.         return \array_keys($this->structure->getChildren());
  274.     }
  276.     public function setType($type)
  277.     {
  278.         $this->readOnlyException(__METHOD__);
  279.     }
  281.     public function getType()
  282.     {
  283.         $document = $this->getDocument();
  284.         $localizationState = $this->inspector->getLocalizationState($document);
  286.         if (LocalizationState::GHOST === $localizationState) {
  287.             return StructureType::getGhost($this->getDocument()->getLocale());
  288.         }
  290.         if (LocalizationState::SHADOW === $this->inspector->getLocalizationState($document)) {
  291.             return StructureType::getShadow($this->getDocument()->getLocale());
  292.         }
  293.     }
  295.     public function getPath()
  296.     {
  297.         return $this->inspector->getContentPath($this->getDocument());
  298.     }
  300.     public function setPath($path)
  301.     {
  302.         $this->readOnlyException(__METHOD__);
  303.     }
  305.     public function setHasTranslation($hasTranslation)
  306.     {
  307.         $this->readOnlyException(__METHOD__);
  308.     }
  310.     public function getHasTranslation()
  311.     {
  312.         return $this->getTitle() ? true : false;
  313.     }
  315.     public function toArray($complete = true)
  316.     {
  317.         $document = $this->getDocument();
  319.         $result = [
  320.             'id' => $this->inspector->getUuid($document),
  321.             'path' => $this->inspector->getContentPath($document),
  322.             'nodeType' => $this->getNodeType(),
  323.             'nodeState' => $this->getNodeState(),
  324.             'internal' => false,
  325.             'availableLocales' => $this->inspector->getLocales($document),
  326.             'contentLocales' => $this->inspector->getConcreteLocales($document),
  327.             'hasSub' => $this->getHasChildren(),
  328.             'title' => $document->getTitle(), // legacy system returns diffent fields for title depending on $complete
  329.         ];
  331.         if ($document instanceof OrderBehavior) {
  332.             $result['order'] = $document->getSuluOrder();
  333.         }
  335.         if ($document instanceof RedirectTypeBehavior) {
  336.             $redirectType = $document->getRedirectType();
  337.             $result['linked'] = null;
  338.             if (RedirectType::INTERNAL == $redirectType && null !== $document->getRedirectTarget()) {
  339.                 $result['linked'] = 'internal';
  340.                 $result['internal_link'] = $document->getRedirectTarget()->getUuid();
  341.             } elseif (RedirectType::EXTERNAL == $redirectType) {
  342.                 $result['linked'] = 'external';
  343.                 $result['external'] = $document->getRedirectExternal();
  344.             }
  345.         }
  347.         if ($document instanceof WorkflowStageBehavior) {
  348.             $result['publishedState'] = WorkflowStage::PUBLISHED === $document->getWorkflowStage();
  349.             $result['published'] = $document->getPublished();
  350.         }
  352.         $result['navContexts'] = [];
  353.         if ($document instanceof NavigationContextBehavior) {
  354.             $result['navContexts'] = $document->getNavigationContexts();
  355.         }
  357.         if (null !== $this->getType()) {
  358.             $result['type'] = $this->getType()->toArray();
  359.         }
  361.         if ($complete) {
  362.             if ($document instanceof ShadowLocaleBehavior) {
  363.                 $result = \array_merge(
  364.                     $result,
  365.                     [
  366.                         'shadowLocales' => $this->inspector->getShadowLocales($document),
  367.                         'shadowOn' => $document->isShadowLocaleEnabled(),
  368.                         'shadowBaseLanguage' => $document->getShadowLocale(),
  369.                     ]
  370.                 );
  371.             }
  373.             $result = \array_merge(
  374.                 $result,
  375.                 [
  376.                     'template' => $this->structure->getName(),
  377.                     'originTemplate' => $this->structure->getName(),
  378.                     'creator' => $document->getCreator(),
  379.                     'changer' => $document->getChanger(),
  380.                     'created' => $document->getCreated(),
  381.                     'changed' => $document->getChanged(),
  382.                     'title' => $document->getTitle(),
  383.                     'url' => null,
  384.                 ]
  385.             );
  387.             if ($document instanceof ResourceSegmentBehavior) {
  388.                 $result['url'] = $document->getResourceSegment();
  389.             }
  391.             if ($document instanceof ExtensionBehavior) {
  392.                 $result['ext'] = $document->getExtensionsData();
  393.             }
  395.             $result = \array_merge($this->getDocument()->getStructure()->toArray(), $result);
  397.             return $result;
  398.         }
  400.         return $result;
  401.     }
  403.     #[\ReturnTypeWillChange]
  404.     public function jsonSerialize()
  405.     {
  406.     }
  408.     public function getPropertyByTagName($tagName, $highest = true)
  409.     {
  410.         return $this->createLegacyPropertyFromItem($this->structure->getPropertyByTagName($tagName, $highest));
  411.     }
  413.     public function getPropertiesByTagName($tagName)
  414.     {
  415.         $properties = [];
  416.         foreach ($this->structure->getPropertiesByTagName($tagName) as $structureProperty) {
  417.             $properties[] = $this->createLegacyPropertyFromItem($structureProperty);
  418.         }
  420.         return $properties;
  421.     }
  423.     public function getPropertyValueByTagName($tagName)
  424.     {
  425.         return $this->getPropertyByTagName($tagName)->getValue();
  426.     }
  428.     public function hasTag($tag)
  429.     {
  430.         return $this->structure->hasPropertyWithTagName($tag);
  431.     }
  433.     public function getNodeType()
  434.     {
  435.         if ($this->getDocument() instanceof RedirectTypeBehavior) {
  436.             return $this->getDocument()->getRedirectType();
  437.         }
  439.         return RedirectType::NONE;
  440.     }
  442.     public function getNodeName()
  443.     {
  444.         if ($this->document instanceof RedirectTypeBehavior &&
  445.             RedirectType::INTERNAL == $this->document->getRedirectType() &&
  446.             null !== $this->document->getRedirectTarget()
  447.         ) {
  448.             return $this->getDocument()->getRedirectTarget()->getTitle();
  449.         }
  451.         return $this->getDocument()->getTitle();
  452.     }
  454.     public function getLocalizedTitle($languageCode)
  455.     {
  456.         return $this->structure->getTitle($languageCode);
  457.     }
  459.     public function getNodeState()
  460.     {
  461.         $document = $this->getDocument();
  463.         if (!$document instanceof WorkflowStageBehavior) {
  464.             return WorkflowStage::PUBLISHED;
  465.         }
  467.         return $this->getDocument()->getWorkflowStage();
  468.     }
  470.     public function getTitle()
  471.     {
  472.         return $this->getDocument()->getTitle();
  473.     }
  475.     public function getUrl()
  476.     {
  477.         return $this->getDocument()->getResourceSegment();
  478.     }
  480.     public function copyFrom(StructureInterface $structure)
  481.     {
  482.         foreach ($this->getProperties(true) as $property) {
  483.             if ($structure->hasProperty($property->getName())) {
  484.                 $property->setValue($structure->getPropertyValue($property->getName()));
  485.             }
  486.         }
  488.         $this->setDocument($structure->getDocument());
  489.     }
  491.     /**
  492.      * Magic getter.
  493.      *
  494.      * @deprecated Do not use magic getters. Use ArrayAccess instead
  495.      */
  496.     public function __get($name)
  497.     {
  498.         return $this->getProperty($name)->getValue();
  499.     }
  501.     public function getShadowLocales()
  502.     {
  503.         return $this->inspector->getShadowLocales($this->getDocument());
  504.     }
  506.     public function getContentLocales()
  507.     {
  508.         return $this->inspector->getConcreteLocales($this->getDocument());
  509.     }
  511.     public function getIsShadow()
  512.     {
  513.         if (!$this->document) {
  514.             return false;
  515.         }
  517.         $document = $this->getDocument();
  518.         if (!$document instanceof ShadowLocaleBehavior) {
  519.             return false;
  520.         }
  522.         return $document->isShadowLocaleEnabled();
  523.     }
  525.     public function getShadowBaseLanguage()
  526.     {
  527.         $document = $this->getDocument();
  528.         if (!$document instanceof ShadowLocaleBehavior) {
  529.             return;
  530.         }
  532.         return $document->getShadowLocale();
  533.     }
  535.     public function getResourceLocator()
  536.     {
  537.         $document = $this->getDocument();
  538.         if (RedirectType::EXTERNAL == $document->getRedirectType()) {
  539.             return $document->getRedirectExternal();
  540.         }
  542.         if (RedirectType::INTERNAL === $document->getRedirectType()) {
  543.             $target = $document->getRedirectTarget();
  545.             if (!$target) {
  546.                 throw new \RuntimeException('Document is an internal redirect, but no redirect target has been set.');
  547.             }
  549.             return $target->getResourceSegment();
  550.         }
  552.         return $document->getResourceSegment();
  553.     }
  555.     /**
  556.      * Returns document.
  557.      *
  558.      * @return object
  559.      */
  560.     public function getDocument()
  561.     {
  562.         if (!$this->document) {
  563.             throw new \RuntimeException(
  564.                 'Document has not been applied to structure yet, cannot retrieve data from structure.'
  565.             );
  566.         }
  568.         return $this->document;
  569.     }
  571.     /**
  572.      * Returns structure metadata.
  573.      *
  574.      * @return StructureMetadata
  575.      */
  576.     public function getStructure()
  577.     {
  578.         return $this->structure;
  579.     }
  581.     protected function readOnlyException($method)
  582.     {
  583.         throw new \BadMethodCallException(
  584.             \sprintf(
  585.                 'Compatibility layer StructureBridge instances are readonly. Tried to call "%s"',
  586.                 $method
  587.             )
  588.         );
  589.     }
  591.     /**
  592.      * @param StructureBehavior $document The document to convert
  593.      *
  594.      * @return $this
  595.      */
  596.     protected function documentToStructure(StructureBehavior $document)
  597.     {
  598.         return new $this(
  599.             $this->inspector->getStructureMetadata($document),
  600.             $this->inspector,
  601.             $this->propertyFactory,
  602.             $document
  603.         );
  604.     }
  606.     private function getWorkflowDocument($method)
  607.     {
  608.         $document = $this->getDocument();
  609.         if (!$document instanceof WorkflowStageBehavior) {
  610.             throw new \BadMethodCallException(
  611.                 \sprintf(
  612.                     'Cannot call "%s" on Document which does not implement PageInterface. Is "%s"',
  613.                     $method,
  614.                     \get_class($document)
  615.                 )
  616.             );
  617.         }
  619.         return $document;
  620.     }
  622.     private function notImplemented($method)
  623.     {
  624.         throw new \InvalidArgumentException(
  625.             \sprintf(
  626.                 'Method "%s" is not yet implemented',
  627.                 $method
  628.             )
  629.         );
  630.     }
  632.     private function normalizeData(array $data = null)
  633.     {
  634.         if (null === $data) {
  635.             return;
  636.         }
  638.         if (false === \is_array($data)) {
  639.             return $this->normalizeValue($data);
  640.         }
  642.         foreach ($data as &$value) {
  643.             if (\is_array($value)) {
  644.                 foreach ($value as $childKey => $childValue) {
  645.                     $data[$childKey] = $this->normalizeData($childValue);
  646.                 }
  647.             }
  649.             $value = $this->normalizeValue($value);
  650.         }
  652.         return $data;
  653.     }
  655.     private function normalizeValue($value)
  656.     {
  657.         if ($value instanceof StructureBehavior) {
  658.             return $this->documentToStructure($value);
  659.         }
  661.         return $value;
  662.     }
  664.     private function createLegacyPropertyFromItem($item)
  665.     {
  666.         $name = $item->getName();
  667.         if (isset($this->loadedProperties[$name])) {
  668.             return $this->loadedProperties[$name];
  669.         }
  671.         $propertyBridge = $this->propertyFactory->createProperty($item, $this);
  673.         if ($this->document) {
  674.             $property = $this->getDocument()->getStructure()->getProperty($name);
  675.             $propertyBridge->setPropertyValue($property);
  676.         }
  678.         $this->loadedProperties[$name] = $propertyBridge;
  680.         return $propertyBridge;
  681.     }
  682. }