vendor/knplabs/doctrine-behaviors/src/EventSubscriber/TranslatableEventSubscriber.php line 58

  1. <?php
  3. declare(strict_types=1);
  5. namespace Knp\DoctrineBehaviors\EventSubscriber;
  7. use Doctrine\Bundle\DoctrineBundle\EventSubscriber\EventSubscriberInterface;
  8. use Doctrine\ORM\Event\LifecycleEventArgs;
  9. use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
  10. use Doctrine\ORM\Events;
  11. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  12. use Doctrine\Persistence\ObjectManager;
  13. use Knp\DoctrineBehaviors\Contract\Entity\TranslatableInterface;
  14. use Knp\DoctrineBehaviors\Contract\Entity\TranslationInterface;
  15. use Knp\DoctrineBehaviors\Contract\Provider\LocaleProviderInterface;
  16. use ReflectionClass;
  18. final class TranslatableEventSubscriber implements EventSubscriberInterface
  19. {
  20.     /**
  21.      * @var string
  22.      */
  23.     public const LOCALE = 'locale';
  25.     private int $translatableFetchMode;
  27.     private int $translationFetchMode;
  29.     public function __construct(
  30.         private LocaleProviderInterface $localeProvider,
  31.         string $translatableFetchMode,
  32.         string $translationFetchMode
  33.     ) {
  34.         $this->translatableFetchMode = $this->convertFetchString($translatableFetchMode);
  35.         $this->translationFetchMode = $this->convertFetchString($translationFetchMode);
  36.     }
  38.     /**
  39.      * Adds mapping to the translatable and translations.
  40.      */
  41.     public function loadClassMetadata(LoadClassMetadataEventArgs $loadClassMetadataEventArgs): void
  42.     {
  43.         $classMetadata = $loadClassMetadataEventArgs->getClassMetadata();
  44.         if (! $classMetadata->reflClass instanceof ReflectionClass) {
  45.             // Class has not yet been fully built, ignore this event
  46.             return;
  47.         }
  49.         if ($classMetadata->isMappedSuperclass) {
  50.             return;
  51.         }
  53.         if (is_a($classMetadata->reflClass->getName(), TranslatableInterface::class, true)) {
  54.             $this->mapTranslatable($classMetadata);
  55.         }
  57.         if (is_a($classMetadata->reflClass->getName(), TranslationInterface::class, true)) {
  58.             $this->mapTranslation($classMetadata, $loadClassMetadataEventArgs->getObjectManager());
  59.         }
  60.     }
  62.     public function postLoad(LifecycleEventArgs $lifecycleEventArgs): void
  63.     {
  64.         $this->setLocales($lifecycleEventArgs);
  65.     }
  67.     public function prePersist(LifecycleEventArgs $lifecycleEventArgs): void
  68.     {
  69.         $this->setLocales($lifecycleEventArgs);
  70.     }
  72.     /**
  73.      * @return string[]
  74.      */
  75.     public function getSubscribedEvents(): array
  76.     {
  77.         return [Events::loadClassMetadata, Events::postLoad, Events::prePersist];
  78.     }
  80.     /**
  81.      * Convert string FETCH mode to required string
  82.      */
  83.     private function convertFetchString(string|int $fetchMode): int
  84.     {
  85.         if (is_int($fetchMode)) {
  86.             return $fetchMode;
  87.         }
  89.         if ($fetchMode === 'EAGER') {
  90.             return ClassMetadataInfo::FETCH_EAGER;
  91.         }
  93.         if ($fetchMode === 'EXTRA_LAZY') {
  94.             return ClassMetadataInfo::FETCH_EXTRA_LAZY;
  95.         }
  97.         return ClassMetadataInfo::FETCH_LAZY;
  98.     }
  100.     private function mapTranslatable(ClassMetadataInfo $classMetadataInfo): void
  101.     {
  102.         if ($classMetadataInfo->hasAssociation('translations')) {
  103.             return;
  104.         }
  106.         $classMetadataInfo->mapOneToMany([
  107.             'fieldName' => 'translations',
  108.             'mappedBy' => 'translatable',
  109.             'indexBy' => self::LOCALE,
  110.             'cascade' => ['persist', 'merge', 'remove'],
  111.             'fetch' => $this->translatableFetchMode,
  112.             'targetEntity' => $classMetadataInfo->getReflectionClass()
  113.                 ->getMethod('getTranslationEntityClass')
  114.                 ->invoke(null),
  115.             'orphanRemoval' => true,
  116.         ]);
  117.     }
  119.     private function mapTranslation(ClassMetadataInfo $classMetadataInfo, ObjectManager $objectManager): void
  120.     {
  121.         if (! $classMetadataInfo->hasAssociation('translatable')) {
  122.             $targetEntity = $classMetadataInfo->getReflectionClass()
  123.                 ->getMethod('getTranslatableEntityClass')
  124.                 ->invoke(null);
  126.             /** @var ClassMetadataInfo $classMetadata */
  127.             $classMetadata = $objectManager->getClassMetadata($targetEntity);
  129.             $singleIdentifierFieldName = $classMetadata->getSingleIdentifierFieldName();
  131.             $classMetadataInfo->mapManyToOne([
  132.                 'fieldName' => 'translatable',
  133.                 'inversedBy' => 'translations',
  134.                 'cascade' => ['persist', 'merge'],
  135.                 'fetch' => $this->translationFetchMode,
  136.                 'joinColumns' => [[
  137.                     'name' => 'translatable_id',
  138.                     'referencedColumnName' => $singleIdentifierFieldName,
  139.                     'onDelete' => 'CASCADE',
  140.                 ]],
  141.                 'targetEntity' => $targetEntity,
  142.             ]);
  143.         }
  145.         $name = $classMetadataInfo->getTableName() . '_unique_translation';
  146.         if (! $this->hasUniqueTranslationConstraint($classMetadataInfo, $name) &&
  147.             $classMetadataInfo->getName() === $classMetadataInfo->rootEntityName) {
  148.             $classMetadataInfo->table['uniqueConstraints'][$name] = [
  149.                 'columns' => ['translatable_id', self::LOCALE],
  150.             ];
  151.         }
  153.         if (! $classMetadataInfo->hasField(self::LOCALE) && ! $classMetadataInfo->hasAssociation(self::LOCALE)) {
  154.             $classMetadataInfo->mapField([
  155.                 'fieldName' => self::LOCALE,
  156.                 'type' => 'string',
  157.                 'length' => 5,
  158.             ]);
  159.         }
  160.     }
  162.     private function setLocales(LifecycleEventArgs $lifecycleEventArgs): void
  163.     {
  164.         $entity = $lifecycleEventArgs->getEntity();
  165.         if (! $entity instanceof TranslatableInterface) {
  166.             return;
  167.         }
  169.         $currentLocale = $this->localeProvider->provideCurrentLocale();
  170.         if ($currentLocale) {
  171.             $entity->setCurrentLocale($currentLocale);
  172.         }
  174.         $fallbackLocale = $this->localeProvider->provideFallbackLocale();
  175.         if ($fallbackLocale) {
  176.             $entity->setDefaultLocale($fallbackLocale);
  177.         }
  178.     }
  180.     private function hasUniqueTranslationConstraint(ClassMetadataInfo $classMetadataInfo, string $name): bool
  181.     {
  182.         return isset($classMetadataInfo->table['uniqueConstraints'][$name]);
  183.     }
  184. }