TranslatableListener::handleTranslatableObjectUpdate()

Complexity

Conditions	53
Paths	> 20000

Size

Total Lines	133
Code Lines	83

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    private function handleTranslatableObjectUpdate(TranslatableAdapter $adapter, $object, $isInsert)
    {
        $manager = $adapter->getObjectManager();
        $wrapped = AbstractWrapper::wrap($object, $manager);
        $meta = $wrapped->getMetadata();
        $config = $this->getConfiguration($manager, $meta->name);
        // no need cache, metadata is loaded only once in MetadataFactoryClass
        $translationClass = $this->getTranslationClass($adapter, $config['useObjectClass']);
        $translationMetadata = $manager->getClassMetadata($translationClass);

        // check for the availability of the primary key
        $objectId = $wrapped->getIdentifier();
        // load the currently used locale
        $locale = $this->getTranslatableLocale($object, $meta, $manager);

        $uow = $manager->getUnitOfWork();
        $oid = spl_object_hash($object);
        $changeSet = $adapter->getObjectChangeSet($uow, $object);
        $translatableFields = $config['fields'];
        foreach ($translatableFields as $field) {
            $wasPersistedSeparetely = false;
            $skip = isset($this->translatedInLocale[$oid]) && $locale === $this->translatedInLocale[$oid];
            $skip = $skip && !isset($changeSet[$field]) && !$this->getTranslationInDefaultLocale($oid, $field);
            if ($skip) {
                continue; // locale is same and nothing changed
            }
            $translation = null;
            foreach ($adapter->getScheduledObjectInsertions($uow) as $trans) {
                if ($locale !== $this->defaultLocale && get_class($trans) === $translationClass && $trans->getLocale() === $this->defaultLocale && $trans->getField() === $field && $this->belongsToObject($adapter, $trans, $object)) {
                    $this->setTranslationInDefaultLocale($oid, $field, $trans);
                    break;
                }
            }

            // lookup persisted translations
            foreach ($adapter->getScheduledObjectInsertions($uow) as $trans) {
                if (get_class($trans) !== $translationClass || $trans->getLocale() !== $locale || $trans->getField() !== $field) {
                    continue;
                }

                if ($adapter->usesPersonalTranslation($translationClass)) {
                    $wasPersistedSeparetely = $trans->getObject() === $object;
                } else {
                    $wasPersistedSeparetely = ($trans->getObjectClass() === $config['useObjectClass'] && $trans->getForeignKey() === $objectId);
                }

                if ($wasPersistedSeparetely) {
                    $translation = $trans;
                    break;
                }
            }

            // check if translation already is created
            if (!$isInsert && !$translation) {
                $translation = $adapter->findTranslation($wrapped, $locale, $field, $translationClass, $config['useObjectClass']);
            }

            // create new translation if translation not already created and locale is different from default locale, otherwise, we have the date in the original record
            $persistNewTranslation = !$translation && ($locale !== $this->defaultLocale || $this->persistDefaultLocaleTranslation);
            if ($persistNewTranslation) {
                $translation = $translationMetadata->newInstance();

The method newInstance() does not exist on Doctrine\Common\Persistence\Mapping\ClassMetadata.

                $translation->setLocale($locale);
                $translation->setField($field);
                if ($adapter->usesPersonalTranslation($translationClass)) {
                    $translation->setObject($object);
                } else {
                    $translation->setObjectClass($config['useObjectClass']);
                    $translation->setForeignKey($objectId);
                }
            }

            if ($translation) {
                // set the translated field, take value using reflection
                $content = $adapter->getTranslationValue($object, $field);
                $translation->setContent($content);
                // check if need to update in database
                $transWrapper = AbstractWrapper::wrap($translation, $manager);
                if (((is_null($content) && !$isInsert) || is_bool($content) || is_int($content) || (is_string($content) && strlen($content) > 0) || !empty($content)) && ($isInsert || !$transWrapper->getIdentifier() || isset($changeSet[$field]))) {
                    if ($isInsert && !$objectId && !$adapter->usesPersonalTranslation($translationClass)) {
                        // if we do not have the primary key yet available
                        // keep this translation in memory to insert it later with foreign key
                        $this->pendingTranslationInserts[spl_object_hash($object)][] = $translation;
                    } else {
                        // persist and compute change set for translation
                        if ($wasPersistedSeparetely) {
                            $adapter->recomputeSingleObjectChangeset($uow, $translationMetadata, $translation);
                        } else {
                            $manager->persist($translation);
                            $uow->computeChangeSet($translationMetadata, $translation);
                        }
                    }
                }
            }

            if ($isInsert && $this->getTranslationInDefaultLocale($oid, $field) !== null) {
                // We can't rely on object field value which is created in non-default locale.
                // If we provide translation for default locale as well, the latter is considered to be trusted
                // and object content should be overridden.
                $wrapped->setPropertyValue($field, $this->getTranslationInDefaultLocale($oid, $field)->getContent());
                $adapter->recomputeSingleObjectChangeset($uow, $meta, $object);
                $this->removeTranslationInDefaultLocale($oid, $field);
            }
        }
        $this->translatedInLocale[$oid] = $locale;
        // check if we have default translation and need to reset the translation
        if (!$isInsert && strlen($this->defaultLocale)) {
            $this->validateLocale($this->defaultLocale);
            $modifiedChangeSet = $changeSet;
            foreach ($changeSet as $field => $changes) {
                if (in_array($field, $translatableFields)) {
                    if ($locale !== $this->defaultLocale) {
                        $adapter->setOriginalObjectProperty($uow, $oid, $field, $changes[0]);
                        unset($modifiedChangeSet[$field]);
                    }
                }
            }
            $adapter->recomputeSingleObjectChangeset($uow, $meta, $object);
            // cleanup current changeset only if working in a another locale different than de default one, otherwise the changeset will always be reverted
            if ($locale !== $this->defaultLocale) {
                $adapter->clearObjectChangeSet($uow, $oid);
                // recompute changeset only if there are changes other than reverted translations
                if ($modifiedChangeSet || $this->hasTranslationsInDefaultLocale($oid)) {
                    foreach ($modifiedChangeSet as $field => $changes) {
                        $adapter->setOriginalObjectProperty($uow, $oid, $field, $changes[0]);
                    }
                    foreach ($translatableFields as $field) {
                        if ($this->getTranslationInDefaultLocale($oid, $field) !== null) {
                            $wrapped->setPropertyValue($field, $this->getTranslationInDefaultLocale($oid, $field)
                                ->getContent());
                            $this->removeTranslationInDefaultLocale($oid, $field);
                        }
                    }
                    $adapter->recomputeSingleObjectChangeset($uow, $meta, $object);
                }