vendor/jms/serializer/src/EventDispatcher/Subscriber/DoctrineProxySubscriber.php line 101

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer\EventDispatcher\Subscriber;
  7. use Doctrine\Common\Persistence\Proxy as LegacyProxy;
  8. use Doctrine\ODM\MongoDB\PersistentCollection as MongoDBPersistentCollection;
  9. use Doctrine\ODM\PHPCR\PersistentCollection as PHPCRPersistentCollection;
  10. use Doctrine\ORM\PersistentCollection;
  11. use Doctrine\Persistence\Proxy;
  12. use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
  13. use JMS\Serializer\EventDispatcher\EventSubscriberInterface;
  14. use JMS\Serializer\EventDispatcher\PreSerializeEvent;
  15. use ProxyManager\Proxy\LazyLoadingInterface;
  17. final class DoctrineProxySubscriber implements EventSubscriberInterface
  18. {
  19.     /**
  20.      * @var bool
  21.      */
  22.     private $skipVirtualTypeInit;
  24.     /**
  25.      * @var bool
  26.      */
  27.     private $initializeExcluded;
  29.     public function __construct(bool $skipVirtualTypeInit = true, bool $initializeExcluded = false)
  30.     {
  31.         $this->skipVirtualTypeInit = $skipVirtualTypeInit;
  32.         $this->initializeExcluded = $initializeExcluded;
  33.     }
  35.     public function onPreSerialize(PreSerializeEvent $event): void
  36.     {
  37.         $object = $event->getObject();
  38.         $type = $event->getType();
  40.         // If the set type name is not an actual class, but a faked type for which a custom handler exists, we do not
  41.         // modify it with this subscriber. Also, we forgo autoloading here as an instance of this type is already created,
  42.         // so it must be loaded if its a real class.
  43.         $virtualType = !class_exists($type['name'], false);
  45.         if (
  46.             $object instanceof PersistentCollection
  47.             || $object instanceof MongoDBPersistentCollection
  48.             || $object instanceof PHPCRPersistentCollection
  49.         ) {
  50.             if (!$virtualType) {
  51.                 $event->setType('ArrayCollection');
  52.             }
  54.             return;
  55.         }
  57.         if (
  58.             ($this->skipVirtualTypeInit && $virtualType) ||
  59.             (!$object instanceof Proxy && !$object instanceof LazyLoadingInterface)
  60.         ) {
  61.             return;
  62.         }
  64.         // do not initialize the proxy if is going to be excluded by-class by some exclusion strategy
  65.         if (false === $this->initializeExcluded && !$virtualType) {
  66.             $context = $event->getContext();
  67.             $exclusionStrategy = $context->getExclusionStrategy();
  68.             $metadata = $context->getMetadataFactory()->getMetadataForClass(get_parent_class($object));
  69.             if (null !== $metadata && null !== $exclusionStrategy && $exclusionStrategy->shouldSkipClass($metadata, $context)) {
  70.                 return;
  71.             }
  72.         }
  74.         if ($object instanceof LazyLoadingInterface) {
  75.             $object->initializeProxy();
  76.         } else {
  77.             $object->__load();
  78.         }
  80.         if (!$virtualType) {
  81.             $event->setType(get_parent_class($object), $type['params']);
  82.         }
  83.     }
  85.     public function onPreSerializeTypedProxy(PreSerializeEvent $event, string $eventName, string $class, string $format, EventDispatcherInterface $dispatcher): void
  86.     {
  87.         $type = $event->getType();
  88.         // is a virtual type? then there is no need to change the event name
  89.         if (!class_exists($type['name'], false)) {
  90.             return;
  91.         }
  93.         $object = $event->getObject();
  94.         if ($object instanceof Proxy) {
  95.             $parentClassName = get_parent_class($object);
  97.             // check if this is already a re-dispatch
  98.             if (strtolower($class) !== strtolower($parentClassName)) {
  99.                 $event->stopPropagation();
  100.                 $newEvent = new PreSerializeEvent($event->getContext(), $object, ['name' => $parentClassName, 'params' => $type['params']]);
  101.                 $dispatcher->dispatch($eventName, $parentClassName, $format, $newEvent);
  103.                 // update the type in case some listener changed it
  104.                 $newType = $newEvent->getType();
  105.                 $event->setType($newType['name'], $newType['params']);
  106.             }
  107.         }
  108.     }
  110.     /**
  111.      * {@inheritdoc}
  112.      */
  113.     public static function getSubscribedEvents()
  114.     {
  115.         return [
  116.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerializeTypedProxy', 'interface' => Proxy::class],
  117.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerializeTypedProxy', 'interface' => LegacyProxy::class],
  118.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => PersistentCollection::class],
  119.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => MongoDBPersistentCollection::class],
  120.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => PHPCRPersistentCollection::class],
  121.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => Proxy::class],
  122.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => LegacyProxy::class],
  123.             ['event' => 'serializer.pre_serialize', 'method' => 'onPreSerialize', 'interface' => LazyLoadingInterface::class],
  124.         ];
  125.     }
  126. }