vendor/sulu/sulu/src/Sulu/Component/DocumentManager/Metadata/BaseMetadataFactory.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\Component\DocumentManager\Metadata;
  14. use PHPCR\NodeInterface;
  15. use Sulu\Component\DocumentManager\ClassNameInflector;
  16. use Sulu\Component\DocumentManager\Event\MetadataLoadEvent;
  17. use Sulu\Component\DocumentManager\Events;
  18. use Sulu\Component\DocumentManager\Exception\MetadataNotFoundException;
  19. use Sulu\Component\DocumentManager\Metadata;
  20. use Sulu\Component\DocumentManager\MetadataFactoryInterface;
  21. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  23. /**
  24.  * Simple metadata factory which uses an array map.
  25.  *
  26.  * Note that this class does not  implement the getMetadataForPhpcrNode method
  27.  * as that would require a circular dependency.
  28.  */
  29. class BaseMetadataFactory implements MetadataFactoryInterface
  30. {
  31.     /**
  32.      * @var array
  33.      */
  34.     private $aliasMap = [];
  36.     /**
  37.      * @var array
  38.      */
  39.     private $classMap = [];
  41.     /**
  42.      * @var array
  43.      */
  44.     private $phpcrTypeMap = [];
  46.     /**
  47.      * @var EventDispatcherInterface
  48.      */
  49.     private $dispatcher;
  51.     /**
  52.      * @var Metadata[]
  53.      */
  54.     private $metadata = [];
  56.     public function __construct(EventDispatcherInterface $dispatcher, array $mapping)
  57.     {
  58.         $this->dispatcher = $dispatcher;
  60.         foreach ($mapping as $map) {
  61.             $this->aliasMap[$map['alias']] = $map;
  62.             $this->classMap[$map['class']] = $map;
  63.             $this->phpcrTypeMap[$map['phpcr_type']] = $map;
  64.         }
  65.     }
  67.     public function getMetadataForAlias($alias)
  68.     {
  69.         if (!isset($this->aliasMap[$alias])) {
  70.             throw new MetadataNotFoundException(\sprintf(
  71.                 'Metadata with alias "%s" not found, known aliases: "%s"',
  72.                 $alias, \implode('", "', \array_keys($this->aliasMap))
  73.             ));
  74.         }
  76.         $map = $this->aliasMap[$alias];
  78.         return $this->loadMetadata($map);
  79.     }
  81.     public function getMetadataForPhpcrType($phpcrType)
  82.     {
  83.         if (!isset($this->phpcrTypeMap[$phpcrType])) {
  84.             throw new MetadataNotFoundException(\sprintf(
  85.                 'Metadata with phpcrType "%s" not found, known phpcrTypes: "%s"',
  86.                 $phpcrType, \implode('", "', \array_keys($this->phpcrTypeMap))
  87.             ));
  88.         }
  90.         $map = $this->phpcrTypeMap[$phpcrType];
  92.         return $this->loadMetadata($map);
  93.     }
  95.     public function hasMetadataForPhpcrType($phpcrType)
  96.     {
  97.         return isset($this->phpcrTypeMap[$phpcrType]);
  98.     }
  100.     public function hasMetadataForClass($class)
  101.     {
  102.         $class = ClassNameInflector::getUserClassName($class);
  104.         return isset($this->classMap[$class]);
  105.     }
  107.     public function getMetadataForClass($class)
  108.     {
  109.         $class = ClassNameInflector::getUserClassName($class);
  111.         if (!isset($this->classMap[$class])) {
  112.             throw new MetadataNotFoundException(\sprintf(
  113.                 'Metadata with class "%s" not found, known classes: "%s"',
  114.                 $class, \implode('", "', \array_keys($this->classMap))
  115.             ));
  116.         }
  118.         $map = $this->classMap[$class];
  120.         return $this->loadMetadata($map);
  121.     }
  123.     public function hasAlias($alias)
  124.     {
  125.         return isset($this->aliasMap[$alias]);
  126.     }
  128.     public function getAliases()
  129.     {
  130.         return \array_keys($this->aliasMap);
  131.     }
  133.     public function getMetadataForPhpcrNode(NodeInterface $node)
  134.     {
  135.         throw new \BadMethodCallException(
  136.             'The BaseMetadataFactory does not implement this method'
  137.         );
  138.     }
  140.     /**
  141.      * @return array
  142.      */
  143.     public function getPhpcrTypeMap()
  144.     {
  145.         return $this->phpcrTypeMap;
  146.     }
  148.     public function getAllMetadata()
  149.     {
  150.         $metadatas = [];
  151.         foreach (\array_keys($this->aliasMap) as $alias) {
  152.             $metadatas[] = $this->getMetadataForAlias($alias);
  153.         }
  155.         return $metadatas;
  156.     }
  158.     /**
  159.      * @param array $mapping
  160.      *
  161.      * @return Metadata
  162.      */
  163.     private function loadMetadata($mapping)
  164.     {
  165.         $mapping = \array_merge([
  166.             'alias' => null,
  167.             'phpcr_type' => null,
  168.             'form_type' => null,
  169.             'class' => null,
  170.             'mapping' => [],
  171.             'sync_remove_live' => true,
  172.             'set_default_author' => true,
  173.         ], $mapping);
  175.         if (isset($this->metadata[$mapping['alias']])) {
  176.             return $this->metadata[$mapping['alias']];
  177.         }
  179.         $metadata = new Metadata();
  180.         $metadata->setAlias($mapping['alias']);
  181.         $metadata->setPhpcrType($mapping['phpcr_type']);
  182.         $metadata->setFormType($mapping['form_type']);
  183.         $metadata->setClass($mapping['class']);
  184.         $metadata->setSyncRemoveLive($mapping['sync_remove_live']);
  185.         $metadata->setDefaultAuthor($mapping['set_default_author']);
  187.         foreach ($mapping['mapping'] as $fieldName => $fieldMapping) {
  188.             $fieldMapping = \array_merge([
  189.                 'encoding' => 'content',
  190.                 'property' => $fieldName,
  191.             ], $fieldMapping);
  192.             $metadata->addFieldMapping($fieldName, $fieldMapping);
  193.         }
  195.         $event = new MetadataLoadEvent($metadata);
  196.         $this->dispatcher->dispatch($event, Events::METADATA_LOAD);
  198.         $this->metadata[$mapping['alias']] = $metadata;
  200.         return $metadata;
  201.     }
  202. }