vendor/gedmo/doctrine-extensions/src/Mapping/MappedEventSubscriber.php line 235

  1. <?php
  3. /*
  4.  * This file is part of the Doctrine Behavioral Extensions package.
  5.  * (c) Gediminas Morkevicius <gediminas.morkevicius@gmail.com> http://www.gediminasm.org
  6.  * For the full copyright and license information, please view the LICENSE
  7.  * file that was distributed with this source code.
  8.  */
  10. namespace Gedmo\Mapping;
  12. use Doctrine\Common\Annotations\AnnotationReader;
  13. use Doctrine\Common\Annotations\PsrCachedReader;
  14. use Doctrine\Common\Annotations\Reader;
  15. use Doctrine\Common\EventArgs;
  16. use Doctrine\Common\EventSubscriber;
  17. use Doctrine\Deprecations\Deprecation;
  18. use Doctrine\ODM\MongoDB\DocumentManager;
  19. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as DocumentClassMetadata;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Doctrine\ORM\Mapping\ClassMetadata as EntityClassMetadata;
  22. use Doctrine\ORM\Mapping\ClassMetadataInfo as LegacyEntityClassMetadata;
  23. use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
  24. use Doctrine\Persistence\Mapping\ClassMetadata;
  25. use Doctrine\Persistence\ObjectManager;
  26. use Gedmo\Exception\InvalidArgumentException;
  27. use Gedmo\Mapping\Driver\AttributeReader;
  28. use Gedmo\Mapping\Event\AdapterInterface;
  29. use Gedmo\Mapping\Event\ClockAwareAdapterInterface;
  30. use Psr\Cache\CacheItemPoolInterface;
  31. use Psr\Clock\ClockInterface;
  32. use Symfony\Component\Cache\Adapter\ArrayAdapter;
  34. /**
  35.  * This is extension of event subscriber class and is
  36.  * used specifically for handling the extension metadata
  37.  * mapping for extensions.
  38.  *
  39.  * It dries up some reusable code which is common for
  40.  * all extensions who maps additional metadata through
  41.  * extended drivers
  42.  *
  43.  * @phpstan-template TConfig of array
  44.  * @phpstan-template TEventAdapter of AdapterInterface
  45.  *
  46.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  47.  */
  48. abstract class MappedEventSubscriber implements EventSubscriber
  49. {
  50.     /**
  51.      * Static List of cached object configurations
  52.      * leaving it static for reasons to look into
  53.      * other listener configuration
  54.      *
  55.      * @var array<string, array<string, array<string, mixed>>>
  56.      *
  57.      * @phpstan-var array<string, array<class-string, array<string, mixed>>>
  58.      */
  59.     protected static $configurations = [];
  61.     /**
  62.      * Listener name, etc: sluggable
  63.      *
  64.      * @var string
  65.      */
  66.     protected $name;
  68.     /**
  69.      * ExtensionMetadataFactory used to read the extension
  70.      * metadata through the extension drivers
  71.      *
  72.      * @var array<int, ExtensionMetadataFactory>
  73.      */
  74.     private array $extensionMetadataFactory = [];
  76.     /**
  77.      * List of event adapters used for this listener
  78.      *
  79.      * @var array<string, AdapterInterface>
  80.      */
  81.     private array $adapters = [];
  83.     /**
  84.      * Custom annotation reader
  85.      *
  86.      * @var Reader|AttributeReader|object|false|null
  87.      */
  88.     private $annotationReader = false;
  90.     /**
  91.      * @var Reader|AttributeReader|false|null
  92.      */
  93.     private static $defaultAnnotationReader = false;
  95.     /**
  96.      * @var CacheItemPoolInterface|null
  97.      */
  98.     private $cacheItemPool;
  100.     private ?ClockInterface $clock = null;
  102.     public function __construct()
  103.     {
  104.         $parts = explode('\\', $this->getNamespace());
  105.         $this->name = end($parts);
  106.     }
  108.     /**
  109.      * Get the configuration for specific object class
  110.      * if cache driver is present it scans it also
  111.      *
  112.      * @param string $class
  113.      *
  114.      * @phpstan-param class-string $class
  115.      *
  116.      * @return array<string, mixed>
  117.      *
  118.      * @phpstan-return TConfig
  119.      */
  120.     public function getConfiguration(ObjectManager $objectManager, $class)
  121.     {
  122.         if (isset(self::$configurations[$this->name][$class])) {
  123.             return self::$configurations[$this->name][$class];
  124.         }
  126.         $config = [];
  128.         $cacheItemPool = $this->getCacheItemPool($objectManager);
  130.         $cacheId = ExtensionMetadataFactory::getCacheId($class, $this->getNamespace());
  131.         $cacheItem = $cacheItemPool->getItem($cacheId);
  133.         if ($cacheItem->isHit()) {
  134.             $config = $cacheItem->get();
  135.             self::$configurations[$this->name][$class] = $config;
  136.         } else {
  137.             // re-generate metadata on cache miss
  138.             $this->loadMetadataForObjectClass($objectManager, $objectManager->getClassMetadata($class));
  139.             if (isset(self::$configurations[$this->name][$class])) {
  140.                 $config = self::$configurations[$this->name][$class];
  141.             }
  142.         }
  144.         $objectClass = $config['useObjectClass'] ?? $class;
  145.         if ($objectClass !== $class) {
  146.             $this->getConfiguration($objectManager, $objectClass);
  147.         }
  149.         return $config;
  150.     }
  152.     /**
  153.      * Get extended metadata mapping reader
  154.      *
  155.      * @return ExtensionMetadataFactory
  156.      */
  157.     public function getExtensionMetadataFactory(ObjectManager $objectManager)
  158.     {
  159.         $oid = spl_object_id($objectManager);
  160.         if (!isset($this->extensionMetadataFactory[$oid])) {
  161.             if (false === $this->annotationReader) {
  162.                 // create default annotation/attribute reader for extensions
  163.                 $this->annotationReader = $this->getDefaultAnnotationReader();
  164.             }
  165.             $this->extensionMetadataFactory[$oid] = new ExtensionMetadataFactory(
  166.                 $objectManager,
  167.                 $this->getNamespace(),
  168.                 $this->annotationReader,
  169.                 $this->getCacheItemPool($objectManager)
  170.             );
  171.         }
  173.         return $this->extensionMetadataFactory[$oid];
  174.     }
  176.     /**
  177.      * Set the annotation reader instance
  178.      *
  179.      * When originally implemented, `Doctrine\Common\Annotations\Reader` was not available,
  180.      * therefore this method may accept any object implementing these methods from the interface:
  181.      *
  182.      *     getClassAnnotations([reflectionClass])
  183.      *     getClassAnnotation([reflectionClass], [name])
  184.      *     getPropertyAnnotations([reflectionProperty])
  185.      *     getPropertyAnnotation([reflectionProperty], [name])
  186.      *
  187.      * @param Reader|AttributeReader|object $reader
  188.      *
  189.      * @return void
  190.      *
  191.      * @note Providing any object is deprecated, as of 4.0 an {@see AttributeReader} will be required
  192.      */
  193.     public function setAnnotationReader($reader)
  194.     {
  195.         if ($reader instanceof Reader) {
  196.             Deprecation::trigger(
  197.                 'gedmo/doctrine-extensions',
  198.                 'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2772',
  199.                 'Annotations support is deprecated, migrate your application to use attributes and pass an instance of %s to the %s() method instead.',
  200.                 AttributeReader::class,
  201.                 __METHOD__
  202.             );
  203.         } elseif (!$reader instanceof AttributeReader) {
  204.             Deprecation::trigger(
  205.                 'gedmo/doctrine-extensions',
  206.                 'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2558',
  207.                 'Providing an annotation reader which does not implement %s or is not an instance of %s to %s() is deprecated.',
  208.                 Reader::class,
  209.                 AttributeReader::class,
  210.                 __METHOD__
  211.             );
  212.         }
  214.         $this->annotationReader = $reader;
  215.     }
  217.     final public function setCacheItemPool(CacheItemPoolInterface $cacheItemPool): void
  218.     {
  219.         $this->cacheItemPool = $cacheItemPool;
  220.     }
  222.     final public function setClock(ClockInterface $clock): void
  223.     {
  224.         $this->clock = $clock;
  225.     }
  227.     /**
  228.      * Scans the objects for extended annotations
  229.      * event subscribers must subscribe to loadClassMetadata event
  230.      *
  231.      * @param ClassMetadata<object> $metadata
  232.      *
  233.      * @return void
  234.      */
  235.     public function loadMetadataForObjectClass(ObjectManager $objectManager, $metadata)
  236.     {
  237.         assert($metadata instanceof DocumentClassMetadata || $metadata instanceof EntityClassMetadata || $metadata instanceof LegacyEntityClassMetadata);
  239.         $factory = $this->getExtensionMetadataFactory($objectManager);
  241.         try {
  242.             $config = $factory->getExtensionMetadata($metadata);
  243.         } catch (\ReflectionException $e) {
  244.             // entity\document generator is running
  245.             $config = []; // will not store a cached version, to remap later
  246.         }
  247.         if ([] !== $config) {
  248.             self::$configurations[$this->name][$metadata->getName()] = $config;
  249.         }
  250.     }
  252.     /**
  253.      * Get an event adapter to handle event specific
  254.      * methods
  255.      *
  256.      * @throws InvalidArgumentException if event is not recognized
  257.      *
  258.      * @return AdapterInterface
  259.      *
  260.      * @phpstan-return TEventAdapter
  261.      */
  262.     protected function getEventAdapter(EventArgs $args)
  263.     {
  264.         $class = get_class($args);
  265.         if (preg_match('@Doctrine\\\([^\\\]+)@', $class, $m) && in_array($m[1], ['ODM', 'ORM'], true)) {
  266.             if (!isset($this->adapters[$m[1]])) {
  267.                 $adapterClass = $this->getNamespace().'\\Mapping\\Event\\Adapter\\'.$m[1];
  268.                 if (!\class_exists($adapterClass)) {
  269.                     $adapterClass = 'Gedmo\\Mapping\\Event\\Adapter\\'.$m[1];
  270.                 }
  271.                 $this->adapters[$m[1]] = new $adapterClass();
  273.                 if ($this->adapters[$m[1]] instanceof ClockAwareAdapterInterface && $this->clock instanceof ClockInterface) {
  274.                     $this->adapters[$m[1]]->setClock($this->clock);
  275.                 }
  276.             }
  277.             $this->adapters[$m[1]]->setEventArgs($args);
  279.             return $this->adapters[$m[1]];
  280.         }
  282.         throw new InvalidArgumentException('Event mapper does not support event arg class: '.$class);
  283.     }
  285.     /**
  286.      * Get the namespace of extension event subscriber.
  287.      * used for cache id of extensions also to know where
  288.      * to find Mapping drivers and event adapters
  289.      *
  290.      * @return string
  291.      */
  292.     abstract protected function getNamespace();
  294.     /**
  295.      * Sets the value for a mapped field
  296.      *
  297.      * @param object $object
  298.      * @param string $field
  299.      * @param mixed  $oldValue
  300.      * @param mixed  $newValue
  301.      *
  302.      * @return void
  303.      */
  304.     protected function setFieldValue(AdapterInterface $adapter, $object, $field, $oldValue, $newValue)
  305.     {
  306.         $manager = $adapter->getObjectManager();
  307.         $meta = $manager->getClassMetadata(get_class($object));
  308.         $uow = $manager->getUnitOfWork();
  310.         $meta->getReflectionProperty($field)->setValue($object, $newValue);
  311.         $uow->propertyChanged($object, $field, $oldValue, $newValue);
  312.         $adapter->recomputeSingleObjectChangeSet($uow, $meta, $object);
  313.     }
  315.     /**
  316.      * Get the default annotation or attribute reader for extensions, creating it if necessary.
  317.      *
  318.      * If a reader cannot be created due to missing requirements, no default will be set as the reader is only required for annotation or attribute metadata,
  319.      * and the {@see ExtensionMetadataFactory} can handle raising an error if it tries to create a mapping driver that requires this reader.
  320.      *
  321.      * @return Reader|AttributeReader|null
  322.      */
  323.     private function getDefaultAnnotationReader()
  324.     {
  325.         if (false === self::$defaultAnnotationReader) {
  326.             if (class_exists(PsrCachedReader::class)) {
  327.                 self::$defaultAnnotationReader = new PsrCachedReader(new AnnotationReader(), new ArrayAdapter());
  328.             } elseif (\PHP_VERSION_ID >= 80000) {
  329.                 self::$defaultAnnotationReader = new AttributeReader();
  330.             } else {
  331.                 self::$defaultAnnotationReader = null;
  332.             }
  333.         }
  335.         return self::$defaultAnnotationReader;
  336.     }
  338.     private function getCacheItemPool(ObjectManager $objectManager): CacheItemPoolInterface
  339.     {
  340.         if (null !== $this->cacheItemPool) {
  341.             return $this->cacheItemPool;
  342.         }
  344.         // TODO: The user should configure its own cache, we are using the one from Doctrine for BC. We should deprecate using
  345.         // the one from Doctrine when the bundle offers an easy way to configure this cache, otherwise users using the bundle
  346.         // will see lots of deprecations without an easy way to avoid them.
  348.         if ($objectManager instanceof EntityManagerInterface || $objectManager instanceof DocumentManager) {
  349.             $metadataFactory = $objectManager->getMetadataFactory();
  350.             $getCache = \Closure::bind(static fn (AbstractClassMetadataFactory $metadataFactory): ?CacheItemPoolInterface => $metadataFactory->getCache(), null, \get_class($metadataFactory));
  352.             $metadataCache = $getCache($metadataFactory);
  354.             if (null !== $metadataCache) {
  355.                 $this->cacheItemPool = $metadataCache;
  357.                 return $this->cacheItemPool;
  358.             }
  359.         }
  361.         $this->cacheItemPool = new ArrayAdapter();
  363.         return $this->cacheItemPool;
  364.     }
  365. }