vendor/sulu/sulu/src/Sulu/Component/Content/Document/Subscriber/StructureSubscriber.php line 378

  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\Document\Subscriber;
  14. use PHPCR\NodeInterface;
  15. use Sulu\Bundle\DocumentManagerBundle\Bridge\DocumentInspector;
  16. use Sulu\Component\Content\Compat\Structure\LegacyPropertyFactory;
  17. use Sulu\Component\Content\ContentTypeManagerInterface;
  18. use Sulu\Component\Content\Document\Behavior\LocalizedStructureBehavior;
  19. use Sulu\Component\Content\Document\Behavior\ShadowLocaleBehavior;
  20. use Sulu\Component\Content\Document\Behavior\StructureBehavior;
  21. use Sulu\Component\Content\Document\LocalizationState;
  22. use Sulu\Component\Content\Document\Structure\ManagedStructure;
  23. use Sulu\Component\Content\Document\Structure\Structure;
  24. use Sulu\Component\Content\Document\Structure\StructureInterface;
  25. use Sulu\Component\Content\Document\Subscriber\PHPCR\SuluNode;
  26. use Sulu\Component\Content\Exception\MandatoryPropertyException;
  27. use Sulu\Component\DocumentManager\Event\AbstractMappingEvent;
  28. use Sulu\Component\DocumentManager\Event\ConfigureOptionsEvent;
  29. use Sulu\Component\DocumentManager\Event\PersistEvent;
  30. use Sulu\Component\DocumentManager\Events;
  31. use Sulu\Component\DocumentManager\PropertyEncoder;
  32. use Sulu\Component\Webspace\Manager\WebspaceManagerInterface;
  33. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  35. class StructureSubscriber implements EventSubscriberInterface
  36. {
  37.     public const STRUCTURE_TYPE_FIELD = 'template';
  39.     /**
  40.      * @var ContentTypeManagerInterface
  41.      */
  42.     private $contentTypeManager;
  44.     /**
  45.      * @var DocumentInspector
  46.      */
  47.     private $inspector;
  49.     /**
  50.      * @var LegacyPropertyFactory
  51.      */
  52.     private $legacyPropertyFactory;
  54.     /**
  55.      * @var PropertyEncoder
  56.      */
  57.     private $encoder;
  59.     /**
  60.      * @var WebspaceManagerInterface
  61.      */
  62.     private $webspaceManager;
  64.     /**
  65.      * @var array
  66.      */
  67.     private $defaultTypes;
  69.     /**
  70.      * @param array $defaultTypes
  71.      */
  72.     public function __construct(
  73.         PropertyEncoder $encoder,
  74.         ContentTypeManagerInterface $contentTypeManager,
  75.         DocumentInspector $inspector,
  76.         LegacyPropertyFactory $legacyPropertyFactory,
  77.         WebspaceManagerInterface $webspaceManager,
  78.         $defaultTypes
  79.     ) {
  80.         $this->encoder = $encoder;
  81.         $this->contentTypeManager = $contentTypeManager;
  82.         $this->inspector = $inspector;
  83.         $this->legacyPropertyFactory = $legacyPropertyFactory;
  84.         $this->webspaceManager = $webspaceManager;
  85.         $this->defaultTypes = $defaultTypes;
  86.     }
  88.     public static function getSubscribedEvents()
  89.     {
  90.         return [
  91.             Events::PERSIST => [
  92.                 // persist should happen before content is mapped
  93.                 ['saveStructureData', 0],
  94.                 // staged properties must be commited before title subscriber
  95.                 ['handlePersistStagedProperties', 50],
  96.                 // setting the structure should happen very early
  97.                 ['handlePersistStructureType', 100],
  98.             ],
  99.             Events::PUBLISH => 'saveStructureData',
  100.             // hydrate should happen afterwards
  101.             Events::HYDRATE => ['handleHydrate', 0],
  102.             Events::CONFIGURE_OPTIONS => 'configureOptions',
  103.         ];
  104.     }
  106.     public function configureOptions(ConfigureOptionsEvent $event)
  107.     {
  108.         $options = $event->getOptions();
  109.         $options->setDefaults(
  110.             [
  111.                 'load_ghost_content' => true,
  112.                 'clear_missing_content' => false,
  113.                 'ignore_required' => false,
  114.                 'structure_type' => null,
  115.             ]
  116.         );
  117.         $options->setAllowedTypes('load_ghost_content', 'bool');
  118.         $options->setAllowedTypes('clear_missing_content', 'bool');
  119.         $options->setAllowedTypes('ignore_required', 'bool');
  120.     }
  122.     /**
  123.      * Set the structure type early so that subsequent subscribers operate
  124.      * upon the correct structure type.
  125.      */
  126.     public function handlePersistStructureType(PersistEvent $event)
  127.     {
  128.         $document = $event->getDocument();
  130.         if (!$this->supportsBehavior($document)) {
  131.             return;
  132.         }
  134.         $structureMetadata = $this->inspector->getStructureMetadata($document);
  136.         $structure = $document->getStructure();
  137.         if ($structure instanceof ManagedStructure) {
  138.             $structure->setStructureMetadata($structureMetadata);
  139.         }
  140.     }
  142.     /**
  143.      * Commit the properties, which are only staged on the structure yet.
  144.      */
  145.     public function handlePersistStagedProperties(PersistEvent $event)
  146.     {
  147.         $document = $event->getDocument();
  149.         if (!$this->supportsBehavior($document)) {
  150.             return;
  151.         }
  153.         $document->getStructure()->commitStagedData($event->getOption('clear_missing_content'));
  154.     }
  156.     public function handleHydrate(AbstractMappingEvent $event)
  157.     {
  158.         $document = $event->getDocument();
  160.         if (!$this->supportsBehavior($document)) {
  161.             return;
  162.         }
  164.         $rehydrate = $event->getOption('rehydrate');
  165.         $structureType = $this->getStructureType($event, $document, $rehydrate);
  167.         $document->setStructureType($structureType);
  169.         if (false === $event->getOption('load_ghost_content', false)) {
  170.             if (LocalizationState::GHOST === $this->inspector->getLocalizationState($document)) {
  171.                 $structureType = null;
  172.             }
  173.         }
  175.         $structure = $this->getStructure($document, $structureType, $rehydrate);
  177.         // Set the property container
  178.         $event->getAccessor()->set(
  179.             'structure',
  180.             $structure
  181.         );
  182.     }
  184.     public function saveStructureData(AbstractMappingEvent $event)
  185.     {
  186.         // Set the structure type
  187.         $document = $event->getDocument();
  189.         if (!$this->supportsBehavior($document)) {
  190.             return;
  191.         }
  193.         if (!$document->getStructureType()) {
  194.             return;
  195.         }
  197.         if (!$event->getLocale()) {
  198.             return;
  199.         }
  201.         $node = $event->getNode();
  202.         $locale = $event->getLocale();
  203.         $options = $event->getOptions();
  205.         $this->mapContentToNode($document, $node, $locale, $options['ignore_required']);
  207.         $node->setProperty(
  208.             $this->getStructureTypePropertyName($document, $locale),
  209.             $document->getStructureType()
  210.         );
  211.     }
  213.     /**
  214.      * @param bool $rehydrate
  215.      *
  216.      * @return string
  217.      */
  218.     private function getStructureType(AbstractMappingEvent $event, StructureBehavior $document, $rehydrate)
  219.     {
  220.         $structureType = $event->getOption('structure_type');
  221.         if ($structureType) {
  222.             return $structureType;
  223.         }
  225.         $node = $event->getNode();
  226.         $locale = $event->getLocale();
  227.         if ($document instanceof ShadowLocaleBehavior && $document->isShadowLocaleEnabled()) {
  228.             $locale = $document->getOriginalLocale();
  229.         }
  230.         $propertyName = $this->getStructureTypePropertyName($document, $locale);
  231.         $structureType = $node->getPropertyValueWithDefault($propertyName, null);
  233.         if (!$structureType && $rehydrate) {
  234.             return $this->getDefaultStructureType($document);
  235.         }
  237.         return $structureType;
  238.     }
  240.     /**
  241.      * Return the default structure for the given StructureBehavior implementing document.
  242.      *
  243.      * @return string
  244.      */
  245.     private function getDefaultStructureType(StructureBehavior $document)
  246.     {
  247.         $alias = $this->inspector->getMetadata($document)->getAlias();
  248.         $webspace = $this->webspaceManager->findWebspaceByKey($this->inspector->getWebspace($document));
  250.         if (!$webspace) {
  251.             return $this->getDefaultStructureTypeFromConfig($alias);
  252.         }
  254.         return $webspace->getDefaultTemplate($alias);
  255.     }
  257.     /**
  258.      * Returns configured "default_type".
  259.      *
  260.      * @param string $alias
  261.      *
  262.      * @return string
  263.      */
  264.     private function getDefaultStructureTypeFromConfig($alias)
  265.     {
  266.         if (!\array_key_exists($alias, $this->defaultTypes)) {
  267.             return;
  268.         }
  270.         return $this->defaultTypes[$alias];
  271.     }
  273.     private function supportsBehavior($document)
  274.     {
  275.         return $document instanceof StructureBehavior;
  276.     }
  278.     private function getStructureTypePropertyName($document, $locale)
  279.     {
  280.         if ($document instanceof LocalizedStructureBehavior) {
  281.             return $this->encoder->localizedSystemName(self::STRUCTURE_TYPE_FIELD, $locale);
  282.         }
  284.         // TODO: This is the wrong namespace, it should be the system namespcae, but we do this for initial BC
  285.         return $this->encoder->contentName(self::STRUCTURE_TYPE_FIELD);
  286.     }
  288.     /**
  289.      * @return ManagedStructure
  290.      */
  291.     private function createStructure($document)
  292.     {
  293.         return new ManagedStructure(
  294.             $this->contentTypeManager,
  295.             $this->legacyPropertyFactory,
  296.             $this->inspector,
  297.             $document
  298.         );
  299.     }
  301.     /**
  302.      * Map to the content properties to the node using the content types.
  303.      *
  304.      * @param string $locale
  305.      * @param bool $ignoreRequired
  306.      *
  307.      * @throws MandatoryPropertyException
  308.      * @throws \RuntimeException
  309.      */
  310.     private function mapContentToNode($document, NodeInterface $node, $locale, $ignoreRequired)
  311.     {
  312.         $structure = $document->getStructure();
  313.         $webspaceName = $this->inspector->getWebspace($document);
  314.         $metadata = $this->inspector->getStructureMetadata($document);
  316.         if (!$metadata) {
  317.             throw new \RuntimeException(
  318.                 \sprintf(
  319.                     'Metadata for Structure Type "%s" was not found, does the file "%s.xml" exists?',
  320.                     $document->getStructureType(),
  321.                     $document->getStructureType()
  322.                 )
  323.             );
  324.         }
  326.         foreach ($metadata->getProperties() as $propertyName => $structureProperty) {
  327.             if (TitleSubscriber::PROPERTY_NAME === $propertyName) {
  328.                 continue;
  329.             }
  331.             $realProperty = $structure->getProperty($propertyName);
  332.             $value = $realProperty->getValue();
  334.             if (false === $ignoreRequired && $structureProperty->isRequired() && null === $value) {
  335.                 throw new MandatoryPropertyException(
  336.                     \sprintf(
  337.                         'Property "%s" in structure "%s" is required but no value was given. Loaded from "%s"',
  338.                         $propertyName,
  339.                         $metadata->getName(),
  340.                         $metadata->getResource()
  341.                     )
  342.                 );
  343.             }
  345.             $contentTypeName = $structureProperty->getType();
  346.             $contentType = $this->contentTypeManager->get($contentTypeName);
  348.             // TODO: Only write if the property has been modified.
  350.             $legacyProperty = $this->legacyPropertyFactory->createTranslatedProperty($structureProperty, $locale);
  351.             $legacyProperty->setValue($value);
  353.             $contentType->write(
  354.                 new SuluNode($node),
  355.                 $legacyProperty,
  356.                 null,
  357.                 $webspaceName,
  358.                 $locale,
  359.                 null
  360.             );
  361.         }
  362.     }
  364.     /**
  365.      * Return the a structure for the document.
  366.      *
  367.      * - If the Structure already exists on the document, use that.
  368.      * - If the Structure type is given, then create a ManagedStructure - this
  369.      *   means that the structure is already persisted on the node and it has data.
  370.      * - If none of the above applies then create a new, empty, Structure.
  371.      *
  372.      * @param object $document
  373.      * @param string $structureType
  374.      * @param bool $rehydrate
  375.      *
  376.      * @return StructureInterface
  377.      */
  378.     private function getStructure($document, $structureType, $rehydrate)
  379.     {
  380.         if ($structureType) {
  381.             return $this->createStructure($document);
  382.         }
  384.         if (!$rehydrate && $document->getStructure()) {
  385.             return $document->getStructure();
  386.         }
  388.         return new Structure();
  389.     }
  390. }