vendor/gedmo/doctrine-extensions/src/Translatable/TranslatableListener.php line 527

  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\Translatable;
  12. use Doctrine\Common\EventArgs;
  13. use Doctrine\ODM\MongoDB\DocumentManager;
  14. use Doctrine\ORM\ORMInvalidArgumentException;
  15. use Doctrine\Persistence\Event\LifecycleEventArgs;
  16. use Doctrine\Persistence\Event\LoadClassMetadataEventArgs;
  17. use Doctrine\Persistence\Event\ManagerEventArgs;
  18. use Doctrine\Persistence\Mapping\ClassMetadata;
  19. use Doctrine\Persistence\ObjectManager;
  20. use Gedmo\Exception\InvalidArgumentException;
  21. use Gedmo\Exception\RuntimeException;
  22. use Gedmo\Mapping\MappedEventSubscriber;
  23. use Gedmo\Tool\Wrapper\AbstractWrapper;
  24. use Gedmo\Translatable\Mapping\Event\TranslatableAdapter;
  26. /**
  27.  * The translation listener handles the generation and
  28.  * loading of translations for entities which implements
  29.  * the Translatable interface.
  30.  *
  31.  * This behavior can impact the performance of your application
  32.  * since it does an additional query for each field to translate.
  33.  *
  34.  * Nevertheless the annotation metadata is properly cached and
  35.  * it is not a big overhead to lookup all entity annotations since
  36.  * the caching is activated for metadata
  37.  *
  38.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  39.  *
  40.  * @phpstan-type TranslatableConfiguration = array{
  41.  *   fields?: string[],
  42.  *   fallback?: array<string, bool>,
  43.  *   locale?: string,
  44.  *   translationClass?: class-string,
  45.  *   useObjectClass?: class-string,
  46.  * }
  47.  *
  48.  * @phpstan-method TranslatableConfiguration getConfiguration(ObjectManager $objectManager, $class)
  49.  *
  50.  * @method TranslatableAdapter getEventAdapter(EventArgs $args)
  51.  *
  52.  * @final since gedmo/doctrine-extensions 3.11
  53.  */
  54. class TranslatableListener extends MappedEventSubscriber
  55. {
  56.     /**
  57.      * Query hint to override the fallback of translations
  58.      * integer 1 for true, 0 false
  59.      */
  60.     public const HINT_FALLBACK = 'gedmo.translatable.fallback';
  62.     /**
  63.      * Query hint to override the fallback locale
  64.      */
  65.     public const HINT_TRANSLATABLE_LOCALE = 'gedmo.translatable.locale';
  67.     /**
  68.      * Query hint to use inner join strategy for translations
  69.      */
  70.     public const HINT_INNER_JOIN = 'gedmo.translatable.inner_join.translations';
  72.     /**
  73.      * Locale which is set on this listener.
  74.      * If Entity being translated has locale defined it
  75.      * will override this one
  76.      *
  77.      * @var string
  78.      */
  79.     protected $locale = 'en_US';
  81.     /**
  82.      * Default locale, this changes behavior
  83.      * to not update the original record field if locale
  84.      * which is used for updating is not default. This
  85.      * will load the default translation in other locales
  86.      * if record is not translated yet
  87.      */
  88.     private string $defaultLocale = 'en_US';
  90.     /**
  91.      * If this is set to false, when if entity does
  92.      * not have a translation for requested locale
  93.      * it will show a blank value
  94.      */
  95.     private bool $translationFallback = false;
  97.     /**
  98.      * List of translations which do not have the foreign
  99.      * key generated yet - MySQL case. These translations
  100.      * will be updated with new keys on postPersist event
  101.      *
  102.      * @var array<int, array<int, object|Translatable>>
  103.      */
  104.     private array $pendingTranslationInserts = [];
  106.     /**
  107.      * Currently in case if there is TranslationQueryWalker
  108.      * in charge. We need to skip issuing additional queries
  109.      * on load
  110.      */
  111.     private bool $skipOnLoad = false;
  113.     /**
  114.      * Tracks locale the objects currently translated in
  115.      *
  116.      * @var array<int, string>
  117.      */
  118.     private array $translatedInLocale = [];
  120.     /**
  121.      * Whether or not, to persist default locale
  122.      * translation or keep it in original record
  123.      */
  124.     private bool $persistDefaultLocaleTranslation = false;
  126.     /**
  127.      * Tracks translation object for default locale
  128.      *
  129.      * @var array<int, array<string, object|Translatable>>
  130.      */
  131.     private array $translationInDefaultLocale = [];
  133.     /**
  134.      * Default translation value upon missing translation
  135.      */
  136.     private ?string $defaultTranslationValue = null;
  138.     /**
  139.      * Specifies the list of events to listen
  140.      *
  141.      * @return string[]
  142.      */
  143.     public function getSubscribedEvents()
  144.     {
  145.         return [
  146.             'postLoad',
  147.             'postPersist',
  148.             'preFlush',
  149.             'onFlush',
  150.             'loadClassMetadata',
  151.         ];
  152.     }
  154.     /**
  155.      * Set to skip or not onLoad event
  156.      *
  157.      * @param bool $bool
  158.      *
  159.      * @return static
  160.      */
  161.     public function setSkipOnLoad($bool)
  162.     {
  163.         $this->skipOnLoad = (bool) $bool;
  165.         return $this;
  166.     }
  168.     /**
  169.      * Whether or not, to persist default locale
  170.      * translation or keep it in original record
  171.      *
  172.      * @param bool $bool
  173.      *
  174.      * @return static
  175.      */
  176.     public function setPersistDefaultLocaleTranslation($bool)
  177.     {
  178.         $this->persistDefaultLocaleTranslation = (bool) $bool;
  180.         return $this;
  181.     }
  183.     /**
  184.      * Check if should persist default locale
  185.      * translation or keep it in original record
  186.      *
  187.      * @return bool
  188.      */
  189.     public function getPersistDefaultLocaleTranslation()
  190.     {
  191.         return (bool) $this->persistDefaultLocaleTranslation;
  192.     }
  194.     /**
  195.      * Add additional $translation for pending $oid object
  196.      * which is being inserted
  197.      *
  198.      * @param int    $oid
  199.      * @param object $translation
  200.      *
  201.      * @return void
  202.      */
  203.     public function addPendingTranslationInsert($oid, $translation)
  204.     {
  205.         $this->pendingTranslationInserts[$oid][] = $translation;
  206.     }
  208.     /**
  209.      * Maps additional metadata
  210.      *
  211.      * @param LoadClassMetadataEventArgs $eventArgs
  212.      *
  213.      * @phpstan-param LoadClassMetadataEventArgs<ClassMetadata<object>, ObjectManager> $eventArgs
  214.      *
  215.      * @return void
  216.      */
  217.     public function loadClassMetadata(EventArgs $eventArgs)
  218.     {
  219.         $this->loadMetadataForObjectClass($eventArgs->getObjectManager(), $eventArgs->getClassMetadata());
  220.     }
  222.     /**
  223.      * Get the translation class to be used
  224.      * for the object $class
  225.      *
  226.      * @param string $class
  227.      *
  228.      * @phpstan-param class-string $class
  229.      *
  230.      * @return string
  231.      *
  232.      * @phpstan-return class-string
  233.      */
  234.     public function getTranslationClass(TranslatableAdapter $ea, $class)
  235.     {
  236.         return self::$configurations[$this->name][$class]['translationClass'] ?? $ea->getDefaultTranslationClass()
  237.         ;
  238.     }
  240.     /**
  241.      * Enable or disable translation fallback
  242.      * to original record value
  243.      *
  244.      * @param bool $bool
  245.      *
  246.      * @return static
  247.      */
  248.     public function setTranslationFallback($bool)
  249.     {
  250.         $this->translationFallback = (bool) $bool;
  252.         return $this;
  253.     }
  255.     /**
  256.      * Weather or not is using the translation
  257.      * fallback to original record
  258.      *
  259.      * @return bool
  260.      */
  261.     public function getTranslationFallback()
  262.     {
  263.         return $this->translationFallback;
  264.     }
  266.     /**
  267.      * Set the locale to use for translation listener
  268.      *
  269.      * @param string $locale
  270.      *
  271.      * @return static
  272.      */
  273.     public function setTranslatableLocale($locale)
  274.     {
  275.         $this->validateLocale($locale);
  276.         $this->locale = $locale;
  278.         return $this;
  279.     }
  281.     /**
  282.      * Set the default translation value on missing translation
  283.      *
  284.      * @deprecated usage of a non nullable value for defaultTranslationValue is deprecated
  285.      * and will be removed on the next major release which will rely on the expected types
  286.      */
  287.     public function setDefaultTranslationValue(?string $defaultTranslationValue): void
  288.     {
  289.         $this->defaultTranslationValue = $defaultTranslationValue;
  290.     }
  292.     /**
  293.      * Sets the default locale, this changes behavior
  294.      * to not update the original record field if locale
  295.      * which is used for updating is not default
  296.      *
  297.      * @param string $locale
  298.      *
  299.      * @return static
  300.      */
  301.     public function setDefaultLocale($locale)
  302.     {
  303.         $this->validateLocale($locale);
  304.         $this->defaultLocale = $locale;
  306.         return $this;
  307.     }
  309.     /**
  310.      * Gets the default locale
  311.      *
  312.      * @return string
  313.      */
  314.     public function getDefaultLocale()
  315.     {
  316.         return $this->defaultLocale;
  317.     }
  319.     /**
  320.      * Get currently set global locale, used
  321.      * extensively during query execution
  322.      *
  323.      * @return string
  324.      */
  325.     public function getListenerLocale()
  326.     {
  327.         return $this->locale;
  328.     }
  330.     /**
  331.      * Gets the locale to use for translation. Loads object
  332.      * defined locale first.
  333.      *
  334.      * @param object        $object
  335.      * @param ClassMetadata $meta
  336.      * @param object        $om
  337.      *
  338.      * @throws RuntimeException if language or locale property is not found in entity
  339.      *
  340.      * @return string
  341.      */
  342.     public function getTranslatableLocale($object, $meta, $om = null)
  343.     {
  344.         $locale = $this->locale;
  345.         $configurationLocale = self::$configurations[$this->name][$meta->getName()]['locale'] ?? null;
  346.         if (null !== $configurationLocale) {
  347.             $class = $meta->getReflectionClass();
  348.             if (!$class->hasProperty($configurationLocale)) {
  349.                 throw new RuntimeException("There is no locale or language property ({$configurationLocale}) found on object: {$meta->getName()}");
  350.             }
  351.             $reflectionProperty = $class->getProperty($configurationLocale);
  352.             $reflectionProperty->setAccessible(true);
  353.             $value = $reflectionProperty->getValue($object);
  354.             if (is_object($value) && method_exists($value, '__toString')) {
  355.                 $value = $value->__toString();
  356.             }
  357.             if ($this->isValidLocale($value)) {
  358.                 $locale = $value;
  359.             }
  360.         } elseif ($om instanceof DocumentManager) {
  361.             [, $parentObject] = $om->getUnitOfWork()->getParentAssociation($object);
  362.             if (null !== $parentObject) {
  363.                 $parentMeta = $om->getClassMetadata(get_class($parentObject));
  364.                 $locale = $this->getTranslatableLocale($parentObject, $parentMeta, $om);
  365.             }
  366.         }
  368.         return $locale;
  369.     }
  371.     /**
  372.      * Handle translation changes in default locale
  373.      *
  374.      * This has to be done in the preFlush because, when an entity has been loaded
  375.      * in a different locale, no changes will be detected.
  376.      *
  377.      * @param ManagerEventArgs $args
  378.      *
  379.      * @phpstan-param ManagerEventArgs<ObjectManager> $args
  380.      *
  381.      * @return void
  382.      */
  383.     public function preFlush(EventArgs $args)
  384.     {
  385.         $ea = $this->getEventAdapter($args);
  386.         $om = $ea->getObjectManager();
  387.         $uow = $om->getUnitOfWork();
  389.         foreach ($this->translationInDefaultLocale as $oid => $fields) {
  390.             $trans = reset($fields);
  392.             assert(false !== $trans);
  394.             if ($ea->usesPersonalTranslation(get_class($trans))) {
  395.                 $entity = $trans->getObject();
  396.             } else {
  397.                 $entity = $uow->tryGetById($trans->getForeignKey(), $trans->getObjectClass());
  398.             }
  400.             if (!$entity) {
  401.                 continue;
  402.             }
  404.             try {
  405.                 $uow->scheduleForUpdate($entity);
  406.             } catch (ORMInvalidArgumentException $e) {
  407.                 foreach ($fields as $field => $trans) {
  408.                     $this->removeTranslationInDefaultLocale($oid, $field);
  409.                 }
  410.             }
  411.         }
  412.     }
  414.     /**
  415.      * Looks for translatable objects being inserted or updated
  416.      * for further processing
  417.      *
  418.      * @param ManagerEventArgs $args
  419.      *
  420.      * @phpstan-param ManagerEventArgs<ObjectManager> $args
  421.      *
  422.      * @return void
  423.      */
  424.     public function onFlush(EventArgs $args)
  425.     {
  426.         $ea = $this->getEventAdapter($args);
  427.         $om = $ea->getObjectManager();
  428.         $uow = $om->getUnitOfWork();
  429.         // check all scheduled inserts for Translatable objects
  430.         foreach ($ea->getScheduledObjectInsertions($uow) as $object) {
  431.             $meta = $om->getClassMetadata(get_class($object));
  432.             $config = $this->getConfiguration($om, $meta->getName());
  433.             if (isset($config['fields'])) {
  434.                 $this->handleTranslatableObjectUpdate($ea, $object, true);
  435.             }
  436.         }
  437.         // check all scheduled updates for Translatable entities
  438.         foreach ($ea->getScheduledObjectUpdates($uow) as $object) {
  439.             $meta = $om->getClassMetadata(get_class($object));
  440.             $config = $this->getConfiguration($om, $meta->getName());
  441.             if (isset($config['fields'])) {
  442.                 $this->handleTranslatableObjectUpdate($ea, $object, false);
  443.             }
  444.         }
  445.         // check scheduled deletions for Translatable entities
  446.         foreach ($ea->getScheduledObjectDeletions($uow) as $object) {
  447.             $meta = $om->getClassMetadata(get_class($object));
  448.             $config = $this->getConfiguration($om, $meta->getName());
  449.             if (isset($config['fields'])) {
  450.                 $wrapped = AbstractWrapper::wrap($object, $om);
  451.                 $transClass = $this->getTranslationClass($ea, $meta->getName());
  452.                 \assert($wrapped instanceof AbstractWrapper);
  453.                 $ea->removeAssociatedTranslations($wrapped, $transClass, $config['useObjectClass']);
  454.             }
  455.         }
  456.     }
  458.     /**
  459.      * Checks for inserted object to update their translation
  460.      * foreign keys
  461.      *
  462.      * @param LifecycleEventArgs $args
  463.      *
  464.      * @phpstan-param LifecycleEventArgs<ObjectManager> $args
  465.      *
  466.      * @return void
  467.      */
  468.     public function postPersist(EventArgs $args)
  469.     {
  470.         $ea = $this->getEventAdapter($args);
  471.         $om = $ea->getObjectManager();
  472.         $object = $ea->getObject();
  473.         $meta = $om->getClassMetadata(get_class($object));
  474.         // check if entity is tracked by translatable and without foreign key
  475.         if ($this->getConfiguration($om, $meta->getName()) && [] !== $this->pendingTranslationInserts) {
  476.             $oid = spl_object_id($object);
  477.             if (array_key_exists($oid, $this->pendingTranslationInserts)) {
  478.                 // load the pending translations without key
  479.                 $wrapped = AbstractWrapper::wrap($object, $om);
  480.                 $objectId = $wrapped->getIdentifier();
  481.                 $translationClass = $this->getTranslationClass($ea, get_class($object));
  482.                 foreach ($this->pendingTranslationInserts[$oid] as $translation) {
  483.                     if ($ea->usesPersonalTranslation($translationClass)) {
  484.                         $translation->setObject($objectId);
  485.                     } else {
  486.                         $translation->setForeignKey($objectId);
  487.                     }
  488.                     $ea->insertTranslationRecord($translation);
  489.                 }
  490.                 unset($this->pendingTranslationInserts[$oid]);
  491.             }
  492.         }
  493.     }
  495.     /**
  496.      * After object is loaded, listener updates the translations
  497.      * by currently used locale
  498.      *
  499.      * @param ManagerEventArgs $args
  500.      *
  501.      * @phpstan-param ManagerEventArgs<ObjectManager> $args
  502.      *
  503.      * @return void
  504.      */
  505.     public function postLoad(EventArgs $args)
  506.     {
  507.         $ea = $this->getEventAdapter($args);
  508.         $om = $ea->getObjectManager();
  509.         $object = $ea->getObject();
  510.         $meta = $om->getClassMetadata(get_class($object));
  511.         $config = $this->getConfiguration($om, $meta->getName());
  512.         $locale = $this->defaultLocale;
  513.         $oid = null;
  514.         if (isset($config['fields'])) {
  515.             $locale = $this->getTranslatableLocale($object, $meta, $om);
  516.             $oid = spl_object_id($object);
  517.             $this->translatedInLocale[$oid] = $locale;
  518.         }
  520.         if ($this->skipOnLoad) {
  521.             return;
  522.         }
  524.         if (isset($config['fields']) && ($locale !== $this->defaultLocale || $this->persistDefaultLocaleTranslation)) {
  525.             // fetch translations
  526.             $translationClass = $this->getTranslationClass($ea, $config['useObjectClass']);
  527.             $result = $ea->loadTranslations(
  528.                 $object,
  529.                 $translationClass,
  530.                 $locale,
  531.                 $config['useObjectClass']
  532.             );
  533.             // translate object's translatable properties
  534.             foreach ($config['fields'] as $field) {
  535.                 $translated = $this->defaultTranslationValue;
  537.                 foreach ($result as $entry) {
  538.                     if ($entry['field'] == $field) {
  539.                         $translated = $entry['content'] ?? null;
  541.                         break;
  542.                     }
  543.                 }
  545.                 // update translation
  546.                 if ($this->defaultTranslationValue !== $translated
  547.                     || (!$this->translationFallback && (!isset($config['fallback'][$field]) || !$config['fallback'][$field]))
  548.                     || ($this->translationFallback && isset($config['fallback'][$field]) && !$config['fallback'][$field])
  549.                 ) {
  550.                     $ea->setTranslationValue($object, $field, $translated);
  551.                     // ensure clean changeset
  552.                     $ea->setOriginalObjectProperty(
  553.                         $om->getUnitOfWork(),
  554.                         $object,
  555.                         $field,
  556.                         $meta->getReflectionProperty($field)->getValue($object)
  557.                     );
  558.                 }
  559.             }
  560.         }
  561.     }
  563.     /**
  564.      * Sets translation object which represents translation in default language.
  565.      *
  566.      * @param int                 $oid   hash of basic entity
  567.      * @param string              $field field of basic entity
  568.      * @param object|Translatable $trans Translation object
  569.      *
  570.      * @return void
  571.      */
  572.     public function setTranslationInDefaultLocale($oid, $field, $trans)
  573.     {
  574.         if (!isset($this->translationInDefaultLocale[$oid])) {
  575.             $this->translationInDefaultLocale[$oid] = [];
  576.         }
  577.         $this->translationInDefaultLocale[$oid][$field] = $trans;
  578.     }
  580.     /**
  581.      * @return bool
  582.      */
  583.     public function isSkipOnLoad()
  584.     {
  585.         return $this->skipOnLoad;
  586.     }
  588.     /**
  589.      * Check if object has any translation object which represents translation in default language.
  590.      * This is for internal use only.
  591.      *
  592.      * @param int $oid hash of the basic entity
  593.      *
  594.      * @return bool
  595.      */
  596.     public function hasTranslationsInDefaultLocale($oid)
  597.     {
  598.         return array_key_exists($oid, $this->translationInDefaultLocale);
  599.     }
  601.     protected function getNamespace()
  602.     {
  603.         return __NAMESPACE__;
  604.     }
  606.     /**
  607.      * Validates the given locale
  608.      *
  609.      * @param string $locale locale to validate
  610.      *
  611.      * @throws InvalidArgumentException if locale is not valid
  612.      *
  613.      * @return void
  614.      */
  615.     protected function validateLocale($locale)
  616.     {
  617.         if (!$this->isValidLocale($locale)) {
  618.             throw new InvalidArgumentException('Locale or language cannot be empty and must be set through Listener or Entity');
  619.         }
  620.     }
  622.     /**
  623.      * Check if the given locale is valid
  624.      */
  625.     private function isValidLocale(?string $locale): bool
  626.     {
  627.         return is_string($locale) && strlen($locale);
  628.     }
  630.     /**
  631.      * Creates the translation for object being flushed
  632.      *
  633.      * @throws \UnexpectedValueException if locale is not valid, or
  634.      *                                   primary key is composite, missing or invalid
  635.      */
  636.     private function handleTranslatableObjectUpdate(TranslatableAdapter $ea, object $object, bool $isInsert): void
  637.     {
  638.         $om = $ea->getObjectManager();
  639.         $wrapped = AbstractWrapper::wrap($object, $om);
  640.         $meta = $wrapped->getMetadata();
  641.         $config = $this->getConfiguration($om, $meta->getName());
  642.         // no need cache, metadata is loaded only once in MetadataFactoryClass
  643.         $translationClass = $this->getTranslationClass($ea, $config['useObjectClass']);
  644.         $translationMetadata = $om->getClassMetadata($translationClass);
  646.         // check for the availability of the primary key
  647.         $objectId = $wrapped->getIdentifier();
  648.         // load the currently used locale
  649.         $locale = $this->getTranslatableLocale($object, $meta, $om);
  651.         $uow = $om->getUnitOfWork();
  652.         $oid = spl_object_id($object);
  653.         $changeSet = $ea->getObjectChangeSet($uow, $object);
  654.         $translatableFields = $config['fields'];
  655.         foreach ($translatableFields as $field) {
  656.             $wasPersistedSeparetely = false;
  657.             $skip = isset($this->translatedInLocale[$oid]) && $locale === $this->translatedInLocale[$oid];
  658.             $skip = $skip && !isset($changeSet[$field]) && !$this->getTranslationInDefaultLocale($oid, $field);
  659.             if ($skip) {
  660.                 continue; // locale is same and nothing changed
  661.             }
  662.             $translation = null;
  663.             foreach ($ea->getScheduledObjectInsertions($uow) as $trans) {
  664.                 if ($locale !== $this->defaultLocale
  665.                     && get_class($trans) === $translationClass
  666.                     && $trans->getLocale() === $this->defaultLocale
  667.                     && $trans->getField() === $field
  668.                     && $this->belongsToObject($ea, $trans, $object)) {
  669.                     $this->setTranslationInDefaultLocale($oid, $field, $trans);
  671.                     break;
  672.                 }
  673.             }
  675.             // lookup persisted translations
  676.             foreach ($ea->getScheduledObjectInsertions($uow) as $trans) {
  677.                 if (get_class($trans) !== $translationClass
  678.                     || $trans->getLocale() !== $locale
  679.                     || $trans->getField() !== $field) {
  680.                     continue;
  681.                 }
  683.                 if ($ea->usesPersonalTranslation($translationClass)) {
  684.                     $wasPersistedSeparetely = $trans->getObject() === $object;
  685.                 } else {
  686.                     $wasPersistedSeparetely = $trans->getObjectClass() === $config['useObjectClass']
  687.                         && $trans->getForeignKey() === $objectId;
  688.                 }
  690.                 if ($wasPersistedSeparetely) {
  691.                     $translation = $trans;
  693.                     break;
  694.                 }
  695.             }
  697.             // check if translation already is created
  698.             if (!$isInsert && !$translation) {
  699.                 \assert($wrapped instanceof AbstractWrapper);
  701.                 $translation = $ea->findTranslation(
  702.                     $wrapped,
  703.                     $locale,
  704.                     $field,
  705.                     $translationClass,
  706.                     $config['useObjectClass']
  707.                 );
  708.             }
  710.             // create new translation if translation not already created and locale is different from default locale, otherwise, we have the date in the original record
  711.             $persistNewTranslation = !$translation
  712.                 && ($locale !== $this->defaultLocale || $this->persistDefaultLocaleTranslation)
  713.             ;
  714.             if ($persistNewTranslation) {
  715.                 $translation = $translationMetadata->newInstance();
  716.                 $translation->setLocale($locale);
  717.                 $translation->setField($field);
  718.                 if ($ea->usesPersonalTranslation($translationClass)) {
  719.                     $translation->setObject($object);
  720.                 } else {
  721.                     $translation->setObjectClass($config['useObjectClass']);
  722.                     $translation->setForeignKey($objectId);
  723.                 }
  724.             }
  726.             if ($translation) {
  727.                 // set the translated field, take value using reflection
  728.                 $content = $ea->getTranslationValue($object, $field);
  729.                 $translation->setContent($content);
  730.                 // check if need to update in database
  731.                 $transWrapper = AbstractWrapper::wrap($translation, $om);
  732.                 if (((null === $content && !$isInsert) || is_bool($content) || is_int($content) || is_string($content) || !empty($content)) && ($isInsert || !$transWrapper->getIdentifier() || isset($changeSet[$field]))) {
  733.                     if ($isInsert && !$objectId && !$ea->usesPersonalTranslation($translationClass)) {
  734.                         // if we do not have the primary key yet available
  735.                         // keep this translation in memory to insert it later with foreign key
  736.                         $this->pendingTranslationInserts[spl_object_id($object)][] = $translation;
  737.                     } else {
  738.                         // persist and compute change set for translation
  739.                         if ($wasPersistedSeparetely) {
  740.                             $ea->recomputeSingleObjectChangeset($uow, $translationMetadata, $translation);
  741.                         } else {
  742.                             $om->persist($translation);
  743.                             $uow->computeChangeSet($translationMetadata, $translation);
  744.                         }
  745.                     }
  746.                 }
  747.             }
  749.             if ($isInsert && null !== $this->getTranslationInDefaultLocale($oid, $field)) {
  750.                 // We can't rely on object field value which is created in non-default locale.
  751.                 // If we provide translation for default locale as well, the latter is considered to be trusted
  752.                 // and object content should be overridden.
  753.                 $wrapped->setPropertyValue($field, $this->getTranslationInDefaultLocale($oid, $field)->getContent());
  754.                 $ea->recomputeSingleObjectChangeset($uow, $meta, $object);
  755.                 $this->removeTranslationInDefaultLocale($oid, $field);
  756.             }
  757.         }
  758.         $this->translatedInLocale[$oid] = $locale;
  759.         // check if we have default translation and need to reset the translation
  760.         if (!$isInsert && strlen($this->defaultLocale)) {
  761.             $this->validateLocale($this->defaultLocale);
  762.             $modifiedChangeSet = $changeSet;
  763.             foreach ($changeSet as $field => $changes) {
  764.                 if (in_array($field, $translatableFields, true)) {
  765.                     if ($locale !== $this->defaultLocale) {
  766.                         $ea->setOriginalObjectProperty($uow, $object, $field, $changes[0]);
  767.                         unset($modifiedChangeSet[$field]);
  768.                     }
  769.                 }
  770.             }
  771.             $ea->recomputeSingleObjectChangeset($uow, $meta, $object);
  772.             // cleanup current changeset only if working in a another locale different than de default one, otherwise the changeset will always be reverted
  773.             if ($locale !== $this->defaultLocale) {
  774.                 $ea->clearObjectChangeSet($uow, $object);
  775.                 // recompute changeset only if there are changes other than reverted translations
  776.                 if ($modifiedChangeSet || $this->hasTranslationsInDefaultLocale($oid)) {
  777.                     foreach ($modifiedChangeSet as $field => $changes) {
  778.                         $ea->setOriginalObjectProperty($uow, $object, $field, $changes[0]);
  779.                     }
  780.                     foreach ($translatableFields as $field) {
  781.                         if (null !== $this->getTranslationInDefaultLocale($oid, $field)) {
  782.                             $wrapped->setPropertyValue($field, $this->getTranslationInDefaultLocale($oid, $field)->getContent());
  783.                             $this->removeTranslationInDefaultLocale($oid, $field);
  784.                         }
  785.                     }
  786.                     $ea->recomputeSingleObjectChangeset($uow, $meta, $object);
  787.                 }
  788.             }
  789.         }
  790.     }
  792.     /**
  793.      * Removes translation object which represents translation in default language.
  794.      * This is for internal use only.
  795.      *
  796.      * @param int    $oid   hash of the basic entity
  797.      * @param string $field field of basic entity
  798.      */
  799.     private function removeTranslationInDefaultLocale(int $oid, string $field): void
  800.     {
  801.         if (isset($this->translationInDefaultLocale[$oid])) {
  802.             if (isset($this->translationInDefaultLocale[$oid][$field])) {
  803.                 unset($this->translationInDefaultLocale[$oid][$field]);
  804.             }
  805.             if (!$this->translationInDefaultLocale[$oid]) {
  806.                 // We removed the final remaining elements from the
  807.                 // translationInDefaultLocale[$oid] array, so we might as well
  808.                 // completely remove the entry at $oid.
  809.                 unset($this->translationInDefaultLocale[$oid]);
  810.             }
  811.         }
  812.     }
  814.     /**
  815.      * Gets translation object which represents translation in default language.
  816.      * This is for internal use only.
  817.      *
  818.      * @param int    $oid   hash of the basic entity
  819.      * @param string $field field of basic entity
  820.      *
  821.      * @return object|Translatable|null Returns translation object if it exists or NULL otherwise
  822.      */
  823.     private function getTranslationInDefaultLocale(int $oid, string $field)
  824.     {
  825.         return $this->translationInDefaultLocale[$oid][$field] ?? null;
  826.     }
  828.     /**
  829.      * Checks if the translation entity belongs to the object in question
  830.      */
  831.     private function belongsToObject(TranslatableAdapter $ea, object $trans, object $object): bool
  832.     {
  833.         if ($ea->usesPersonalTranslation(get_class($trans))) {
  834.             return $trans->getObject() === $object;
  835.         }
  837.         return $trans->getForeignKey() === $object->getId()
  838.             && ($trans->getObjectClass() === get_class($object));
  839.     }
  840. }