vendor/sulu/sulu/src/Sulu/Bundle/PageBundle/Content/Structure/ExcerptStructureExtension.php line 163

  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\Bundle\PageBundle\Content\Structure;
  14. use PHPCR\NodeInterface;
  15. use Sulu\Bundle\SearchBundle\Search\Factory;
  16. use Sulu\Component\Content\Compat\PropertyInterface;
  17. use Sulu\Component\Content\Compat\StructureInterface;
  18. use Sulu\Component\Content\Compat\StructureManagerInterface;
  19. use Sulu\Component\Content\ContentTypeExportInterface;
  20. use Sulu\Component\Content\ContentTypeManagerInterface;
  21. use Sulu\Component\Content\Extension\AbstractExtension;
  22. use Sulu\Component\Content\Extension\ExportExtensionInterface;
  23. use Sulu\Component\Content\Mapper\Translation\TranslatedProperty;
  24. use Sulu\Component\Export\Manager\ExportManagerInterface;
  25. use Sulu\Component\Import\Manager\ImportManagerInterface;
  27. /**
  28.  * extends structure with seo content.
  29.  */
  30. class ExcerptStructureExtension extends AbstractExtension implements ExportExtensionInterface
  31. {
  32.     /**
  33.      * name of structure extension.
  34.      */
  35.     public const EXCERPT_EXTENSION_NAME = 'excerpt';
  37.     /**
  38.      * will be filled with data in constructor
  39.      * {@inheritdoc}
  40.      */
  41.     protected $properties = [];
  43.     protected $name = self::EXCERPT_EXTENSION_NAME;
  45.     protected $additionalPrefix = self::EXCERPT_EXTENSION_NAME;
  47.     /**
  48.      * @var ContentTypeManagerInterface
  49.      */
  50.     protected $contentTypeManager;
  52.     /**
  53.      * @var StructureManagerInterface
  54.      */
  55.     protected $structureManager;
  57.     /**
  58.      * @var ExportManagerInterface
  59.      */
  60.     protected $exportManager;
  62.     /**
  63.      * @var ImportManagerInterface
  64.      */
  65.     protected $importManager;
  67.     /**
  68.      * @var string
  69.      */
  70.     private $languageNamespace;
  72.     /**
  73.      * @var string
  74.      */
  75.     private $languageCode;
  77.     /**
  78.      * @var Factory
  79.      */
  80.     private $factory;
  82.     public function __construct(
  83.         StructureManagerInterface $structureManager,
  84.         ContentTypeManagerInterface $contentTypeManager,
  85.         ExportManagerInterface $exportManager,
  86.         ImportManagerInterface $importManager,
  87.         Factory $factory
  88.     ) {
  89.         $this->contentTypeManager = $contentTypeManager;
  90.         $this->structureManager = $structureManager;
  91.         $this->exportManager = $exportManager;
  92.         $this->importManager = $importManager;
  93.         $this->factory = $factory;
  94.     }
  96.     public function save(NodeInterface $node, $data, $webspaceKey, $languageCode)
  97.     {
  98.         $this->setLanguageCode($languageCode, 'i18n', null);
  100.         $excerptStructure = $this->getExcerptStructure($languageCode);
  102.         foreach ($excerptStructure->getProperties() as $property) {
  103.             $contentType = $this->contentTypeManager->get($property->getContentTypeName());
  105.             if (\array_key_exists($property->getName(), $data)) {
  106.                 $property->setValue($data[$property->getName()]);
  107.                 $contentType->write(
  108.                     $node,
  109.                     new TranslatedProperty(
  110.                         $property,
  111.                         $languageCode,
  112.                         $this->languageNamespace,
  113.                         $this->additionalPrefix
  114.                     ),
  115.                     null, // userid
  116.                     $webspaceKey,
  117.                     $languageCode,
  118.                     null // segmentkey
  119.                 );
  120.             }
  121.         }
  122.     }
  124.     public function load(NodeInterface $node, $webspaceKey, $languageCode)
  125.     {
  126.         $excerptStructure = $this->getExcerptStructure($languageCode);
  128.         $data = [];
  129.         foreach ($excerptStructure->getProperties() as $property) {
  130.             $contentType = $this->contentTypeManager->get($property->getContentTypeName());
  131.             $contentType->read(
  132.                 $node,
  133.                 new TranslatedProperty(
  134.                     $property,
  135.                     $languageCode,
  136.                     $this->languageNamespace,
  137.                     $this->additionalPrefix
  138.                 ),
  139.                 $webspaceKey,
  140.                 $languageCode,
  141.                 null // segmentkey
  142.             );
  144.             $data[$property->getName()] = $property->getValue();
  145.         }
  147.         return $data;
  148.     }
  150.     public function setLanguageCode($languageCode, $languageNamespace, $namespace)
  151.     {
  152.         // lazy load excerpt structure to avoid redeclaration of classes
  153.         // should be done before parent::setLanguageCode because it uses the $thi<->properties
  154.         // which will be set in initExcerptStructure
  155.         $this->initProperties($languageCode);
  157.         $this->languageCode = $languageCode;
  158.         $this->languageNamespace = $languageNamespace;
  160.         parent::setLanguageCode($languageCode, $languageNamespace, $namespace);
  161.     }
  163.     public function getContentData($container)
  164.     {
  165.         $container = new ExcerptValueContainer($container);
  167.         $data = [];
  168.         foreach ($this->getExcerptStructure()->getProperties() as $property) {
  169.             if ($container->__isset($property->getName())) {
  170.                 $property->setValue($container->__get($property->getName()));
  171.                 $contentType = $this->contentTypeManager->get($property->getContentTypeName());
  172.                 $data[$property->getName()] = $contentType->getContentData($property);
  173.             }
  174.         }
  176.         return $data;
  177.     }
  179.     public function getFieldMapping()
  180.     {
  181.         $mappings = parent::getFieldMapping();
  183.         foreach ($this->getExcerptStructure()->getPropertiesByTagName('sulu.search.field') as $property) {
  184.             $tag = $property->getTag('sulu.search.field');
  185.             $tagAttributes = $tag->getAttributes();
  187.             $mappings['excerpt' . \ucfirst($property->getName())] = [
  188.                 'type' => isset($tagAttributes['type']) ? $tagAttributes['type'] : 'string',
  189.                 'field' => $this->factory->createMetadataExpression(
  190.                     \sprintf('object.getExtensionsData()["excerpt"]["%s"]', $property->getName())
  191.                 ),
  192.             ];
  193.         }
  195.         return $mappings;
  196.     }
  198.     /**
  199.      * Returns and caches excerpt-structure.
  200.      *
  201.      * @param string $locale
  202.      *
  203.      * @return StructureInterface
  204.      */
  205.     private function getExcerptStructure($locale = null)
  206.     {
  207.         if (null === $locale) {
  208.             $locale = $this->languageCode;
  209.         }
  211.         $excerptStructure = $this->structureManager->getStructure(self::EXCERPT_EXTENSION_NAME);
  212.         $excerptStructure->setLanguageCode($locale);
  214.         return $excerptStructure;
  215.     }
  217.     /**
  218.      * Initiates structure and properties.
  219.      *
  220.      * @param string $locale
  221.      */
  222.     private function initProperties($locale)
  223.     {
  224.         // Reset the properties before new initialization.
  225.         $this->properties = [];
  227.         /** @var PropertyInterface $property */
  228.         foreach ($this->getExcerptStructure($locale)->getProperties() as $property) {
  229.             $this->properties[] = $property->getName();
  230.         }
  231.     }
  233.     public function export($properties, $format = null)
  234.     {
  235.         $container = new ExcerptValueContainer($properties);
  237.         $data = [];
  238.         foreach ($this->getExcerptStructure()->getProperties() as $property) {
  239.             if ($container->__isset($property->getName())) {
  240.                 $property->setValue($container->__get($property->getName()));
  241.                 $contentType = $this->contentTypeManager->get($property->getContentTypeName());
  242.                 if ($this->exportManager->hasExport($property->getContentTypeName(), $format)) {
  243.                     $options = $this->exportManager->getOptions($property->getContentTypeName(), $format);
  245.                     $data[$property->getName()] = [
  246.                         'name' => $property->getName(),
  247.                         'value' => $contentType->exportData($property->getValue()),
  248.                         'type' => $property->getContentTypeName(),
  249.                         'options' => $options,
  250.                     ];
  251.                 }
  252.             }
  253.         }
  255.         return $data;
  256.     }
  258.     public function getImportPropertyNames()
  259.     {
  260.         $propertyNames = [];
  262.         foreach ($this->getExcerptStructure()->getProperties() as $property) {
  263.             $propertyNames[] = $property->getName();
  264.         }
  266.         return $propertyNames;
  267.     }
  269.     public function import(NodeInterface $node, $data, $webspaceKey, $languageCode, $format)
  270.     {
  271.         $this->setLanguageCode($languageCode, 'i18n', null);
  273.         foreach ($this->getExcerptStructure()->getProperties() as $property) {
  274.             $contentType = $this->contentTypeManager->get($property->getContentTypeName());
  276.             if (isset($data[$property->getName()])
  277.                 && $this->importManager->hasImport($property->getContentTypeName(), $format)
  278.             ) {
  279.                 /* @var ContentTypeExportInterface $contentType */
  280.                 $contentType->importData(
  281.                     $node,
  282.                     new TranslatedProperty(
  283.                         $property,
  284.                         $languageCode,
  285.                         $this->languageNamespace,
  286.                         $this->additionalPrefix
  287.                     ),
  288.                     $data[$property->getName()],
  289.                     null, // userid
  290.                     $webspaceKey,
  291.                     $languageCode,
  292.                     null // segmentkey
  293.                 );
  294.             }
  295.         }
  296.     }
  297. }