Merge pull request #17 from pfilipkowskilemon/dev-issue-9

Add support for localized field in object bricks, classification stores and fieldcollections

Author: asioso

src/QuickTranslateBundle/Controller/ObjectController.php

@@ -29,7 +29,39 @@ public function translateObjectAction(Request $request)
             $item = DataObject::getById($itemId);
 
             foreach ($data as $key => $value) {
-                $item->set($key, $value, $localizedField);
+                if (str_contains($key, 'structuredData#')) {
+                    list($prefix, $fieldName, $index, $type, $strField) = explode('.', $key);
+
+                    $structuredField = $item->get($fieldName);
+
+                    if ($structuredField instanceof DataObject\Fieldcollection) {
+                        $structuredField->setObject($item);
+                        $structuredField->get($index)->set($strField, $value, $localizedField);
+                    }
+
+                    if ($structuredField instanceof DataObject\Objectbrick) {
+                        $structuredField->setObject($item);
+                        $structuredField->get($type)->set($strField, $value, $localizedField);
+                    }
+
+                    if (is_array($structuredField) && $type === 'undefined') {
+                        $blockItem = $structuredField[$index];
+                        $localizedFields = $blockItem['localizedfields']->getData();
+                        $localizedFields->setLocalizedValue($strField, $value, $localizedField);
+                    }
+
+                } elseif (str_contains($key, 'classificationStore#')) {
+                    list($prefix, $index, $fieldName, $strField) = explode('.', $key);
+
+                    $structuredField = $item->get($fieldName);
+
+                    if ($structuredField instanceof DataObject\Classificationstore) {
+                        $structuredField->setObject($item);
+                        $structuredField->setLocalizedKeyValue($index, $strField, $value, $localizedField);
+                    }
+                } else {
+                    $item->set($key, $value, $localizedField);
+                }
             }
 
             $item->save();

src/QuickTranslateBundle/Resources/public/js/pimcore/startup.js

@@ -27,6 +27,19 @@ pimcore.plugin.asiosoQuickTranslateBundle = Class.create(pimcore.plugin.admin, {
         if (type === "object") {
             if (object.data.data.hasOwnProperty("localizedfields")) {
                 object.tabbar.add(new pimcore.element.quickTranslateObjectBtn(object, "object").getLayout());
+            } else if (object.data.data) {
+                let objectData = object.data.data;
+                for (let item in objectData) {
+                    if (Array.isArray(objectData[item])) {
+                        objectData[item].forEach((element) => {
+                            if (objectData[item].length && element.data.localizedfields) {
+                                object.tabbar.add(new pimcore.element.quickTranslateObjectBtn(object, "object").getLayout());
+                            }
+                        })
+                    } else if (!Array.isArray(objectData[item]) && typeof objectData[item] === 'object' && objectData[item] !== null && objectData[item].hasOwnProperty('activeGroups')) {
+                        object.tabbar.add(new pimcore.element.quickTranslateObjectBtn(object, "object").getLayout());
+                    }
+                }
             }
         }
     },

src/QuickTranslateBundle/Resources/public/js/quick-translate-btn/quickTranslateObjectBtn.js

@@ -99,8 +99,40 @@ pimcore.element.quickTranslateObjectBtn = Class.create({
 
                                         if (!langs.includes(null)) {
 
-                                            var data = this.element.data.data.localizedfields.data[langs[0]];
-                                            var xmlStr = "";
+                                            var data = {},
+                                                xmlStr = "",
+                                                elementData = this.element.data.data;
+                                            if (elementData.hasOwnProperty('localizedfields')) {
+                                                data = { ...data, ...elementData.localizedfields.data[langs[0]] }
+                                            }
+                                            for (let item in elementData) {
+                                                if (Array.isArray(elementData[item])) {
+                                                    elementData[item].forEach((element, index) => {
+                                                        if(element !== null && element.data?.localizedfields !== undefined) {
+                                                            if (elementData[item].length && element.data.localizedfields.data[langs[0]]) {
+                                                                let localizedFields = element.data.localizedfields.data[langs[0]];
+                                                                for (let field in localizedFields) {
+                                                                    localizedFields[`structuredData#.${item}.${index}.${element.type}.${field}`] = localizedFields[field];
+                                                                    delete localizedFields[field];
+                                                                }
+                                                                data = {...data, ...localizedFields}
+                                                            }
+                                                        }
+                                                    })
+                                                } else if (!Array.isArray(elementData[item]) && typeof elementData[item] === 'object' && elementData[item] !== null && elementData[item].hasOwnProperty('activeGroups')) {
+                                                    if (elementData[item].data[langs[0]]) {
+                                                        let localizedFields = elementData[item].data[langs[0]];
+                                                        for (let storeObject in localizedFields) {
+                                                            for (let field in localizedFields[storeObject]) {
+                                                                localizedFields[storeObject][`classificationStore#.${storeObject}.${item}.${field}`] = localizedFields[storeObject][field];
+                                                                delete localizedFields[storeObject][field];
+                                                            }
+                                                            data = { ...data, ...localizedFields[storeObject] }
+                                                        }
+                                                    }
+                                                }
+                                            }
+
 
                                             for (var field in data) {