vendor/sulu/sulu/src/Sulu/Bundle/MediaBundle/Content/Types/MediaSelectionContentType.php line 97

  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\MediaBundle\Content\Types;
  14. use PHPCR\NodeInterface;
  15. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\AnyOfsMetadata;
  16. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\ArrayMetadata;
  17. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\EmptyArrayMetadata;
  18. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\NullMetadata;
  19. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\NumberMetadata;
  20. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\ObjectMetadata;
  21. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\PropertyMetadata;
  22. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\PropertyMetadataMapperInterface;
  23. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\PropertyMetadataMinMaxValueResolver;
  24. use Sulu\Bundle\AdminBundle\Metadata\SchemaMetadata\StringMetadata;
  25. use Sulu\Bundle\MediaBundle\Content\MediaSelectionContainer;
  26. use Sulu\Bundle\MediaBundle\Media\Manager\MediaManagerInterface;
  27. use Sulu\Bundle\WebsiteBundle\ReferenceStore\ReferenceStoreInterface;
  28. use Sulu\Component\Content\Compat\PropertyInterface;
  29. use Sulu\Component\Content\Compat\PropertyParameter;
  30. use Sulu\Component\Content\ComplexContentType;
  31. use Sulu\Component\Content\ContentTypeExportInterface;
  32. use Sulu\Component\Content\Metadata\PropertyMetadata as ContentPropertyMetadata;
  33. use Sulu\Component\Content\PreResolvableContentTypeInterface;
  34. use Sulu\Component\Security\Authorization\PermissionTypes;
  35. use Sulu\Component\Util\ArrayableInterface;
  36. use Sulu\Component\Webspace\Analyzer\RequestAnalyzerInterface;
  38. /**
  39.  * content type for image selection.
  40.  */
  41. class MediaSelectionContentType extends ComplexContentType implements ContentTypeExportInterface, PreResolvableContentTypeInterface, PropertyMetadataMapperInterface
  42. {
  43.     /**
  44.      * @var MediaManagerInterface
  45.      */
  46.     private $mediaManager;
  48.     /**
  49.      * @var ReferenceStoreInterface
  50.      */
  51.     private $referenceStore;
  53.     /**
  54.      * @var RequestAnalyzerInterface
  55.      */
  56.     private $requestAnalyzer;
  58.     /**
  59.      * @var ?array
  60.      */
  61.     private $permissions;
  63.     /**
  64.      * @var PropertyMetadataMinMaxValueResolver|null
  65.      */
  66.     private $propertyMetadataMinMaxValueResolver;
  68.     public function __construct(
  69.         MediaManagerInterface $mediaManager,
  70.         ReferenceStoreInterface $referenceStore,
  71.         RequestAnalyzerInterface $requestAnalyzer = null,
  72.         $permissions = null,
  73.         ?PropertyMetadataMinMaxValueResolver $propertyMetadataMinMaxValueResolver = null
  74.     ) {
  75.         $this->mediaManager = $mediaManager;
  76.         $this->referenceStore = $referenceStore;
  77.         $this->requestAnalyzer = $requestAnalyzer;
  78.         $this->permissions = $permissions;
  79.         $this->propertyMetadataMinMaxValueResolver = $propertyMetadataMinMaxValueResolver;
  80.     }
  82.     public function getDefaultParams(PropertyInterface $property = null)
  83.     {
  84.         return [
  85.             'types' => new PropertyParameter('types', null),
  86.             'formats' => new PropertyParameter('formats', []),
  87.         ];
  88.     }
  90.     /**
  91.      * @param array $params
  92.      *
  93.      * @return PropertyParameter[]
  94.      */
  95.     public function getParams($params)
  96.     {
  97.         return \array_merge($this->getDefaultParams(), $params);
  98.     }
  100.     public function read(
  101.         NodeInterface $node,
  102.         PropertyInterface $property,
  103.         $webspaceKey,
  104.         $languageCode,
  105.         $segmentKey
  106.     ) {
  107.         $data = \json_decode($node->getPropertyValueWithDefault($property->getName(), '{"ids": []}'), true);
  109.         $property->setValue(isset($data['ids']) ? $data : null);
  110.     }
  112.     public function write(
  113.         NodeInterface $node,
  114.         PropertyInterface $property,
  115.         $userId,
  116.         $webspaceKey,
  117.         $languageCode,
  118.         $segmentKey
  119.     ) {
  120.         $value = $property->getValue();
  121.         if ($value instanceof ArrayableInterface) {
  122.             $value = $value->toArray();
  123.         }
  125.         // if whole smart-content container is pushed
  126.         if (isset($value['data'])) {
  127.             unset($value['data']);
  128.         }
  130.         // set value to node
  131.         $node->setProperty($property->getName(), \json_encode($value));
  132.     }
  134.     public function remove(
  135.         NodeInterface $node,
  136.         PropertyInterface $property,
  137.         $webspaceKey,
  138.         $languageCode,
  139.         $segmentKey
  140.     ) {
  141.         if ($node->hasProperty($property->getName())) {
  142.             $node->getProperty($property->getName())->remove();
  143.         }
  144.     }
  146.     public function getContentData(PropertyInterface $property)
  147.     {
  148.         $data = $property->getValue();
  150.         $params = $this->getParams($property->getParams());
  151.         $types = $params['types']->getValue();
  153.         $webspace = $this->requestAnalyzer->getWebspace();
  155.         $container = new MediaSelectionContainer(
  156.             isset($data['config']) ? $data['config'] : [],
  157.             isset($data['displayOption']) ? $data['displayOption'] : '',
  158.             isset($data['ids']) ? $data['ids'] : [],
  159.             $property->getStructure()->getLanguageCode(),
  160.             $types,
  161.             $this->mediaManager,
  162.             $webspace && $webspace->hasWebsiteSecurity() ? $this->permissions[PermissionTypes::VIEW] : null
  163.         );
  165.         return $container->getData();
  166.     }
  168.     public function getViewData(PropertyInterface $property)
  169.     {
  170.         return $property->getValue();
  171.     }
  173.     public function exportData($propertyValue)
  174.     {
  175.         if (!\is_array($propertyValue)) {
  176.             return '';
  177.         }
  179.         if (!empty($propertyValue)) {
  180.             return \json_encode($propertyValue);
  181.         }
  183.         return '';
  184.     }
  186.     public function importData(
  187.         NodeInterface $node,
  188.         PropertyInterface $property,
  189.         $value,
  190.         $userId,
  191.         $webspaceKey,
  192.         $languageCode,
  193.         $segmentKey = null
  194.     ) {
  195.         $property->setValue(\json_decode($value, true));
  196.         $this->write($node, $property, $userId, $webspaceKey, $languageCode, $segmentKey);
  197.     }
  199.     public function preResolve(PropertyInterface $property)
  200.     {
  201.         $data = $property->getValue();
  202.         if (!isset($data['ids']) || !\is_array($data['ids'])) {
  203.             return;
  204.         }
  206.         foreach ($data['ids'] as $id) {
  207.             $this->referenceStore->add($id);
  208.         }
  209.     }
  211.     public function mapPropertyMetadata(ContentPropertyMetadata $propertyMetadata): PropertyMetadata
  212.     {
  213.         $mandatory = $propertyMetadata->isRequired();
  215.         $minMaxValue = (object) [
  216.             'min' => null,
  217.             'max' => null,
  218.         ];
  220.         if (null !== $this->propertyMetadataMinMaxValueResolver) {
  221.             $minMaxValue = $this->propertyMetadataMinMaxValueResolver->resolveMinMaxValue($propertyMetadata);
  222.         }
  224.         $idsMetadata = new ArrayMetadata(
  225.             new NumberMetadata(),
  226.             $minMaxValue->min,
  227.             $minMaxValue->max,
  228.             true
  229.         );
  231.         if (!$mandatory) {
  232.             $idsMetadata = new AnyOfsMetadata([
  233.                 new EmptyArrayMetadata(),
  234.                 $idsMetadata,
  235.             ]);
  236.         }
  238.         $mediaSelectionMetadata = new ObjectMetadata([
  239.             new PropertyMetadata('ids', $mandatory, $idsMetadata),
  240.             new PropertyMetadata('displayOption', false, new StringMetadata()),
  241.         ]);
  243.         if (!$mandatory) {
  244.             $mediaSelectionMetadata = new AnyOfsMetadata([
  245.                 new NullMetadata(),
  246.                 $mediaSelectionMetadata,
  247.             ]);
  248.         }
  250.         return new PropertyMetadata($propertyMetadata->getName(), $mandatory, $mediaSelectionMetadata);
  251.     }
  252. }