@gudhub/core 1.1.125 → 1.1.127

package/GUDHUB/Utils/AppsTemplateService/AppsTemplateService.js

@@ -1,3 +1,5 @@
+import { GudHub } from "../../gudhub.js";
+
 export default class AppsTemplateService {
     constructor(gudhub) {
         this.gudhub = gudhub;
@@ -6,370 +8,332 @@ export default class AppsTemplateService {
             fields: [],
             items: [],
             views: []
-        }
+        };
     }
 
-    createAppsFromTemplate(pack, maxNumberOfInsstalledItems, progressCallback, installFromMaster) {
-        const self = this;
-        return new Promise(resolve => {
-            const stepsCount = pack.apps.length * 6;
-            const stepPercents = 100 / stepsCount;
-            let currentStep = 0;
-            self.createApps(pack, (status) => {
-                currentStep += 1;
-                progressCallback ? progressCallback.call(this, {
-                    percent: currentStep * stepPercents,
-                    status
-                }) : null;
-            }, installFromMaster).then(success => {
-                self.createItems(success, maxNumberOfInsstalledItems, (status) => {
-                    if (typeof status === 'string') {
-                        currentStep += 1;
-                        progressCallback ? progressCallback.call(this, {
-                            percent: currentStep * stepPercents,
-                            status
-                        }) : null;
-                    } else if (typeof status === 'object') {
-                        progressCallback ? progressCallback.call(this, {
-                            status: 'Done',
-                            apps: status
-                        }) : null;
-                        resolve();
-                    }
-                }, installFromMaster)
+    async createAppsFromTemplate(pack, remoteServerUrl, remoteServerAuthKey, isInstallFromRemoteServer, maxNumberOfInstalledItems, progressCallback) {
+        const stepsCount = pack.apps.length * 6;
+        const stepPercents = 100 / stepsCount;
+        let currentStep = 0;
+
+        const remoteServerGudHubInstance = isInstallFromRemoteServer
+            ? new GudHub(remoteServerAuthKey, { 
+                server_url: `${remoteServerUrl}/GudHub` 
             })
-        });
+            : null;
+
+        const appsList = await remoteServerGudHubInstance.getAppsList();
+
+        const onAppStep = (status) => {
+            currentStep += 1;
+            progressCallback?.({ percent: currentStep * stepPercents, status });
+        };
+
+        const onItemStep = (status) => {
+            if (typeof status === 'string') {
+                currentStep += 1;
+                progressCallback?.({ percent: currentStep * stepPercents, status });
+            } else if (typeof status === 'object') {
+                progressCallback?.({ status: 'Done', apps: status });
+            }
+        };
+
+        const createdApps = await this._createApps(pack, remoteServerUrl, remoteServerAuthKey, isInstallFromRemoteServer, remoteServerGudHubInstance, onAppStep);
+        await this._createItems(createdApps, remoteServerUrl, remoteServerAuthKey, isInstallFromRemoteServer, remoteServerGudHubInstance, maxNumberOfInstalledItems, onItemStep);
     }
 
-    createItems(create_apps, maxNumberOfInsstalledItems, callback, installFromMaster) {
-        return new Promise(async (resolve) => {
-            const MAX_NUMBER_OF_INSTALLED_ITEMS = maxNumberOfInsstalledItems ? maxNumberOfInsstalledItems : 100000;
-            const self = this;
-            let createsItems = [];
-            let promises = [];
+    // Fetches source apps, clones them as new ones and builds ID mapping between old and new entities
+    async _createApps(pack, remoteServerUrl, remoteServerAuthKey, isInstallFromRemoteServer, remoteServerGudHubInstance, callback) {
+        const source_apps = {};
+        const created_apps = [];
+        const updated_apps = [];
 
-            const { accesstoken } = await self.gudhub.req.axiosRequest({
+        let accesstoken = null;
+
+        if (isInstallFromRemoteServer) {
+            const response = await this.gudhub.req.axiosRequest({
                 method: 'POST',
-                url: 'https://app.gudhub.com/GudHub/auth/login',
-                form: {
-                    auth_key: '3HMOtCbC0M/1/1e4y4Uxo/Kh/aFN4V5LG2//5ixx7TZyiUfMb7IHAAHCj9PsLrOSDrZuuWkbX4BIX23f51H+eA=='
-                }
+                url: `${remoteServerUrl}/GudHub/auth/login`,
+                form: { auth_key: remoteServerAuthKey }
             });
 
-            create_apps.forEach(app => {
-                promises.push(new Promise(async (app_resolve) => {
-                    let result_app;
-                    if(installFromMaster) {
-                        result_app = await self.gudhub.req.axiosRequest({ url: `https://app.gudhub.com/GudHub/api/app/get?token=${accesstoken}&app_id=${self._searchOldAppId(app.app_id, self.appsConnectingMap.apps)}`, method: 'GET' });
-                    } else {
-                        result_app = await self.gudhub.getApp(self._searchOldAppId(app.app_id, self.appsConnectingMap.apps));
-                    }
-                    callback ? callback.call(this, `GET APP: ${result_app.app_name} (Items steps)`) : null;
-                    let source_app = JSON.parse(JSON.stringify(result_app));
-                    let items = source_app.items_list.map(item => {
-                        return {
-                            index_number: item.index_number,
-                            item_id: 0,
-                            fields: []
-                        }
-                    }).filter((item, index) => index <= MAX_NUMBER_OF_INSTALLED_ITEMS);
-                    self.gudhub.addNewItems(app.app_id, items).then(items => {
-                        callback ? callback.call(this, `ADD NEW ITEMS: ${result_app.app_name} (Items steps)`) : null;
+            accesstoken = response.accesstoken;
+        }
 
-                        app.items_list = items;
-                        self._updateMap(app.items_list, source_app.items_list);
-                        self._addFieldValue(source_app.items_list, app.items_list, self.appsConnectingMap);
+        for (const app_id of pack.apps) {
+            let result_app;
 
-                        createsItems.push(app);
+            if (isInstallFromRemoteServer) {
+                result_app = await this.gudhub.req.axiosRequest({
+                    url: `${remoteServerUrl}/GudHub/api/app/get?token=${accesstoken}&app_id=${app_id}`,
+                    method: 'GET'
+                });
+            } else {
+                result_app = await this.gudhub.getApp(app_id);
+            }
 
-                        app_resolve();
-                    });
-                }));
-            });
+            if (!result_app) {
+                throw new Error(`Failed to get app: ${app_id}`);
+            }
 
-            Promise.all(promises).then(() => {
+            callback?.(`GET APP: ${result_app.app_name} (App steps)`);
 
-            createsItems.forEach(app => {
-                app.items_list.forEach(item => {
-                    item.fields.forEach(field_item => {
-                        self.appsConnectingMap.fields.forEach(field_map => {
-                            if (field_item.field_id === field_map.old_field_id) {
-                                field_item.field_id = field_map.new_field_id;
-                                field_item.element_id = field_map.new_field_id;
-                            }
-                        })
-                    })
-                })
+            const source_app = JSON.parse(JSON.stringify(result_app));
+            source_apps[source_app.app_id] = source_app;
+
+            let appTemplate = this._prepareAppTemplate(source_app);
+            appTemplate.privacy = 1;
+
+            if (pack.data_to_change) {
+                if (pack.data_to_change.name) appTemplate.app_name = pack.data_to_change.name;
+                if (pack.data_to_change.icon) appTemplate.icon = pack.data_to_change.icon;
+            }
+
+            this._resetViewsIds(appTemplate);
+
+            const created_app = await this.gudhub.createNewApp(appTemplate);
+            callback?.(`CREATE NEW APP: ${result_app.app_name} (App steps)`);
+
+            created_apps.push(created_app);
+            this._mapApp(source_app, created_app, this.appsConnectingMap);
+        }
+
+        this._connectApps(created_apps, this.appsConnectingMap, source_apps);
+
+        for (const created_app of created_apps) {
+            const updated_app = await this.gudhub.updateApp(created_app);
+            callback?.(`UPDATE APP: ${updated_app.app_name} (App steps)`);
+            updated_apps.push(updated_app);
+        }
+
+        return updated_apps;
+    }
+
+    // Creates items for each app and restores their data with proper ID remapping
+    async _createItems(create_apps, remoteServerUrl, remoteServerAuthKey, isInstallFromRemoteServer, remoteServerGudHubInstance, maxNumberOfInstalledItems, callback) {
+        const MAX_NUMBER_OF_INSTALLED_ITEMS = maxNumberOfInstalledItems ?? 100000;
+
+        let accesstoken = null;
+
+        if (isInstallFromRemoteServer) {
+            const response = await this.gudhub.req.axiosRequest({
+                method: 'POST',
+                url: `${remoteServerUrl}/GudHub/auth/login`,
+                form: { auth_key: remoteServerAuthKey }
             });
+            accesstoken = response.accesstoken;
+        }
 
-            self.deleteField(createsItems);
-
-            self.replaceValue(createsItems, self.appsConnectingMap).then(() => {
-                
-                const promises = [];
-
-                createsItems.forEach(created_app => {
-                    promises.push(new Promise(resolve => {
-                        let newItems = created_app.items_list.map(item => {
-                            item.fields.forEach(field => {
-                                delete field.data_id;
-                            });
-                            return item;
-                        });
-                        
-                        self.gudhub.updateItems(created_app.app_id, newItems).then(() => {
-                            callback ? callback.call(this, `REPLACE VALUE: ${created_app.app_name} (Items steps)`) : null;
-                            resolve();
-                        })
-                    }));
-                });
-                
-                Promise.all(promises).then(() => {
-                    callback.call(this, createsItems);
-                    resolve();
+        const createdItems = await Promise.all(create_apps.map(async (app) => {
+            let result_app;
+
+            if (isInstallFromRemoteServer) {
+                result_app = await this.gudhub.req.axiosRequest({
+                    url: `${remoteServerUrl}/GudHub/api/app/get?token=${accesstoken}&app_id=${this._searchOldAppId(app.app_id, this.appsConnectingMap.apps)}`,
+                    method: 'GET'
                 });
+            } else {
+                result_app = await this.gudhub.getApp(this._searchOldAppId(app.app_id, this.appsConnectingMap.apps));
+            }
+
+            if (!result_app) {
+                throw new Error(`Failed to get app in createItems: ${app.app_id}`);
+            }
+
+            callback?.(`GET APP: ${result_app.app_name} (Items steps)`);
+
+            const source_app = JSON.parse(JSON.stringify(result_app));
+            const items = source_app.items_list
+                .map(item => ({ index_number: item.index_number, item_id: 0, fields: [] }))
+                .filter((_, index) => index <= MAX_NUMBER_OF_INSTALLED_ITEMS);
+
+            const newItems = await this.gudhub.addNewItems(app.app_id, items);
+            callback?.(`ADD NEW ITEMS: ${result_app.app_name} (Items steps)`);
+
+            app.items_list = newItems;
+            this._updateMap(app.items_list, source_app.items_list);
+            this._addFieldValue(source_app.items_list, app.items_list, this.appsConnectingMap);
+
+            return app;
+        }));
+
+        for (const app of createdItems) {
+            for (const item of app.items_list) {
+                for (const field_item of item.fields) {
+                    for (const field_map of this.appsConnectingMap.fields) {
+                        if (field_item.field_id === field_map.old_field_id) {
+                            field_item.field_id = field_map.new_field_id;
+                            field_item.element_id = field_map.new_field_id;
+                        }
+                    }
+                }
+            }
+        }
 
+        this._deleteField(createdItems);
+        await this._replaceValue(
+            createdItems,
+            this.appsConnectingMap,
+            isInstallFromRemoteServer,
+            remoteServerGudHubInstance
+        );
+
+        await Promise.all(createdItems.map(async (created_app) => {
+            const newItems = created_app.items_list.map(item => {
+                item.fields.forEach(field => { delete field.data_id; });
+                return item;
             });
-            })
-        })
+
+            await this.gudhub.updateItems(created_app.app_id, newItems);
+            callback?.(`REPLACE VALUE: ${created_app.app_name} (Items steps)`);
+        }));
+
+        callback?.(createdItems);
     }
 
-    deleteField(apps) {
-        apps.forEach(app => {
-            app.items_list.forEach(item => {
-                item.fields = item.fields.filter(field => {
-                    return app.field_list.findIndex(f => f.field_id == field.field_id) > -1;
-                })
-            })
-        })
+    // Ensures items only contain fields that still exist in the app schema
+    _deleteField(apps) {
+        for (const app of apps) {
+            for (const item of app.items_list) {
+                item.fields = item.fields.filter(field =>
+                    app.field_list.findIndex(f => f.field_id == field.field_id) > -1
+                );
+            }
+        }
     }
 
-    replaceValue(apps, map) {
-        return new Promise(async (resolve) => {
-            const allPromises = [];
-            const self = this;
+    // Handles post-processing of field values (files, documents, references)
+    async _replaceValue(apps, map, isInstallFromRemoteServer, remoteServerGudHubInstance) {
+        const allPromises = [];
+        const mapAppIds = map?.apps;
 
-            apps.forEach(app => {
-                app.field_list.forEach(field_of_list => {
-                    if (field_of_list.data_type === 'item_ref') {
-                        self._replaceValueItemRef(app, field_of_list, map);
-                    }
+        for (const app of apps) {
+            for (const field_of_list of app.field_list) {
+                if (field_of_list.data_type === 'item_ref') {
+                    this._replaceValueItemRef(app, field_of_list, map);
+                }
 
-                    allPromises.push(new Promise(resolve => {
-                            self.gudhub.ghconstructor.getInstance(field_of_list.data_type).then(data => {
-                                if(typeof data === 'undefined') {
-                                    console.log('ERROR WHILE GETTING INSTANCE OF ', field_of_list.data_type);
-                                    resolve({
-                                        type: field_of_list.data_type
-                                    });
-                                    return;
-                                }
-                                if (data.getTemplate().constructor == 'file') {
-                                    return self.gudhub.util.fileInstallerHelper(app.app_id, app.items_list, field_of_list.field_id).then(result => {
-                                        resolve(result);
-                                    });
-                                } else if (data.getTemplate().constructor == 'document') {
-                                    self.documentInstallerHelper(app.app_id, app.items_list, field_of_list.field_id).then(result => {
-                                        resolve(data);
-                                    })
-                                } else {
-                                    resolve(data);
-                                }
-                            })
-                    }))
-                })
-            });
+                allPromises.push(
+                    this.gudhub.ghconstructor.getInstance(field_of_list.data_type).then(async (data) => {
+                        if (typeof data === 'undefined') {
+                            return { type: field_of_list.data_type };
+                        }
 
-            if (allPromises.length > 0) {
+                        if (data.getTemplate().constructor === 'file') {
+                            return this.gudhub.util.fileInstallerHelper(
+                                mapAppIds,
+                                app.app_id,
+                                app.items_list,
+                                field_of_list.field_id,
+                                isInstallFromRemoteServer,
+                                remoteServerGudHubInstance
+                            );
+                        }
 
-                Promise.all(allPromises).then(result => {
-                    resolve(result);
-                });
+                        if (data.getTemplate().constructor === 'document') {
+                            await this._documentInstallerHelper(app.app_id, app.items_list, field_of_list.field_id);
+                            return data;
+                        }
 
-            } else {
-                resolve(result);
+                        return data;
+                    })
+                );
             }
+        }
 
-        });
+        if (allPromises.length > 0) {
+            return Promise.all(allPromises);
+        }
     }
 
-    documentInstallerHelper(appId, items, elementId) {
-        const self = this;
+    // Clones documents so new items don’t reference original app data
+    async _documentInstallerHelper(appId, items, elementId) {
         const itemsWithClonedDocument = [];
 
-        return new Promise(async (resolve) => {
-            for(const item of items) {
-                const itemId = item.item_id;
-                const field = item.fields.find(field => field.element_id === elementId);
-
-                if (field && field.field_value && field.field_value.length > 0) {
-                    const document = await self.gudhub.getDocument({
-                        _id: field.field_value
-                    });
+        for (const item of items) {
+            const field = item.fields.find(field => field.element_id === elementId);
 
-                    if(document && document.data) {
-                    
-                        const newDocument = await self.gudhub.createDocument({
-                            app_id: appId,
-                            item_id: itemId,
-                            element_id: elementId,
-                            data: document.data
-                        });
+            if (field?.field_value?.length > 0) {
+                const document = await this.gudhub.getDocument({ _id: field.field_value });
 
-                        field.field_value = newDocument._id;
+                if (document?.data) {
+                    const newDocument = await this.gudhub.createDocument({
+                        app_id: appId,
+                        item_id: item.item_id,
+                        element_id: elementId,
+                        data: document.data
+                    });
 
-                        itemsWithClonedDocument.push(item);
-                    }
+                    field.field_value = newDocument._id;
+                    itemsWithClonedDocument.push(item);
                 }
             }
-            resolve(itemsWithClonedDocument);
-        });
+        }
+
+        return itemsWithClonedDocument;
     }
 
+    // Rewrites item_ref values to point to newly created apps/items instead of old ones
     _replaceValueItemRef(app, field_of_list, map) {
-        app.items_list.forEach(item => {
-            item.fields.forEach(field_of_item => {
+        for (const item of app.items_list) {
+            for (const field_of_item of item.fields) {
                 if (field_of_item.field_id === field_of_list.field_id && field_of_item.field_value) {
-                    let arr_values = field_of_item.field_value.split(',');
-
-                    arr_values.forEach((one_value, key) => {
-                        let value = one_value.split('.');
-
-                        map.apps.forEach(app_ids => {
-                            if (value[0] == app_ids.old_app_id) {
-                                value[0] = app_ids.new_app_id;
-                            }
-                        });
+                    const arr_values = field_of_item.field_value.split(',').map(one_value => {
+                        const value = one_value.split('.');
 
-                        map.items.forEach(item_ids => {
-                            if (value[1] == item_ids.old_item_id) {
-                                value[1] = item_ids.new_item_id;
-                            }
-                        });
+                        for (const app_ids of map.apps) {
+                            if (value[0] == app_ids.old_app_id) value[0] = app_ids.new_app_id;
+                        }
 
-                        arr_values[key] = value.join('.')
+                        for (const item_ids of map.items) {
+                            if (value[1] == item_ids.old_item_id) value[1] = item_ids.new_item_id;
+                        }
 
+                        return value.join('.');
                     });
 
                     field_of_item.field_value = arr_values.join(',');
-
                 }
-            });
-        })
+            }
+        }
     }
 
+    // Copies field values from source items into newly created items
     _addFieldValue(source_app_items, create_items, appsConnectingMap) {
-        create_items.forEach(new_item => {
-            appsConnectingMap.items.forEach(item_of_map => {
+        for (const new_item of create_items) {
+            for (const item_of_map of appsConnectingMap.items) {
                 if (new_item.item_id === item_of_map.new_item_id) {
-                    source_app_items.forEach(old_item => {
+                    for (const old_item of source_app_items) {
                         if (item_of_map.old_item_id === old_item.item_id) {
                             new_item.fields = old_item.fields;
                         }
-                    })
+                    }
                 }
-            })
-        })
+            }
+        }
     }
 
+    // Builds mapping between old and new item IDs (based on index consistency)
     _updateMap(new_items, old_items) {
-        old_items.forEach(old_item => {
-            new_items.forEach(new_item => {
+        for (const old_item of old_items) {
+            for (const new_item of new_items) {
                 if (old_item.index_number === new_item.index_number) {
                     this.appsConnectingMap.items.push({
                         old_item_id: old_item.item_id,
                         new_item_id: new_item.item_id
-                    })
+                    });
                 }
-            })
-        })
-    }
-
-    _searchOldAppId(app_id, apps) {
-        let findId = 0;
-
-        apps.forEach(value => {
-            if (value.new_app_id === app_id) {
-                findId = value.old_app_id;
             }
-        });
-
-        return findId;
-    }
-
-    createApps(pack, callback, installFromMaster) {
-        const self = this;
-
-        let progress = {
-            step_size: 100 / (pack.apps.length * 3),
-            apps: []
         }
+    }
 
-        return new Promise(async (resolve) => {
-            let source_apps = {};
-            let created_apps = [];
-            let updated_apps = [];
-
-            const { accesstoken } = await self.gudhub.req.axiosRequest({
-                method: 'POST',
-                url: 'https://app.gudhub.com/GudHub/auth/login',
-                form: {
-                    auth_key: '3HMOtCbC0M/1/1e4y4Uxo/Kh/aFN4V5LG2//5ixx7TZyiUfMb7IHAAHCj9PsLrOSDrZuuWkbX4BIX23f51H+eA=='
-                }
-            });
-
-            for(const app_id of pack.apps) {
-                let result_app;
-
-                if(installFromMaster) {
-                    result_app = await self.gudhub.req.axiosRequest({ url: `https://app.gudhub.com/GudHub/api/app/get?token=${accesstoken}&app_id=${app_id}`, method: 'GET' });
-                } else {
-                    result_app = await self.gudhub.getApp(app_id);
-                }
-               
-                callback ? callback.call(this, `GET APP: ${result_app.app_name} (App steps)`) : null;
-                let source_app = JSON.parse(JSON.stringify(result_app));
-                source_apps[source_app.app_id] = source_app;
-                progress.apps.push(source_app.icon);
-
-                let appTemplate = self.prepareAppTemplate(source_app);
-                appTemplate.app_name = appTemplate.app_name;
-                appTemplate.privacy = 1;
-                if(pack.data_to_change) {
-                    if(pack.data_to_change.name) {
-                        appTemplate.app_name = pack.data_to_change.name;
-                    }
-                    if(pack.data_to_change.icon) {
-                        appTemplate.icon = pack.data_to_change.icon;
-                    }
-                }
-                self.resetViewsIds(appTemplate);
-
-                self.gudhub.createNewApp(appTemplate).then(created_app => {
-                    callback ? callback.call(this, `CREATE NEW APP: ${result_app.app_name} (App steps)`) : null;
-                    created_apps.push(created_app);
-                    self.mapApp(source_app, created_app, self.appsConnectingMap);
-
-                    if (pack.apps.length == created_apps.length) {
-                        self.connectApps(created_apps, self.appsConnectingMap, source_apps);
-
-                        created_apps.forEach(created_app => {
-                            self.gudhub.updateApp(created_app).then(updated_app => {
-                                callback ? callback.call(this, `UPDATE APP: ${result_app.app_name} (App steps)`) : null;
-                                updated_apps.push(updated_app);
-
-                                if (pack.apps.length == updated_apps.length) {
-                                    resolve(updated_apps);
-                                }
-                            })
-                        })
-                    }
-                });
-            }
-        });
+    // Resolves original app ID from mapping (used when syncing data)
+    _searchOldAppId(app_id, apps) {
+        return apps.find(value => value.new_app_id === app_id)?.old_app_id ?? 0;
     }
 
-    mapApp(base_app, new_app, appsConnectingMap) {
+    // Stores mapping between old/new apps, fields and views for later ID replacement
+    _mapApp(base_app, new_app, appsConnectingMap) {
         appsConnectingMap.apps.push({
             old_app_id: base_app.app_id,
             new_app_id: new_app.app_id,
@@ -377,196 +341,179 @@ export default class AppsTemplateService {
             new_view_init: new_app.view_init
         });
 
-        base_app.field_list.forEach(old_field => {
-            new_app.field_list.forEach(new_field => {
-                if (old_field.name_space == new_field.name_space) {
+        for (const old_field of base_app.field_list) {
+            for (const new_field of new_app.field_list) {
+                if (old_field.name_space === new_field.name_space) {
                     appsConnectingMap.fields.push({
                         name_space: old_field.name_space,
                         old_field_id: old_field.field_id,
                         new_field_id: new_field.field_id
-                    })
+                    });
                 }
-            })
-        });
+            }
+        }
 
-        base_app.views_list.forEach(old_view => {
-            new_app.views_list.forEach(new_view => {
-                if (old_view.name == new_view.name) {
+        for (const old_view of base_app.views_list) {
+            for (const new_view of new_app.views_list) {
+                if (old_view.name === new_view.name) {
                     appsConnectingMap.views.push({
                         name: old_view.name,
                         old_view_id: old_view.view_id,
                         new_view_id: new_view.view_id
-                    })
+                    });
                 }
-            })
-        })
+            }
+        }
     }
 
-    crawling(object, action) {
-        let properties = object === null ? [] : Object.keys(object);
-        const self = this;
+    // Generic recursive walker to traverse deeply nested objects
+    _crawling(object, action) {
+        if (object === null) return;
 
-        if (properties.length > 0) {
-            properties.forEach(prop => {
-                let propertyValue = object[prop];
+        const properties = Object.keys(object);
 
-                if (typeof propertyValue !== 'undefined' && typeof object != 'string') {
-                    action(prop, propertyValue, object);
-                    self.crawling(propertyValue, action);
-                }
-            })
+        for (const prop of properties) {
+            const propertyValue = object[prop];
+
+            if (typeof propertyValue !== 'undefined' && typeof object !== 'string') {
+                action(prop, propertyValue, object);
+                this._crawling(propertyValue, action);
+            }
         }
     }
 
-    resetViewsIds(app) {
+    // Resets all view-related IDs to avoid collisions when cloning
+    _resetViewsIds(app) {
         app.view_init = 0;
 
-        this.crawling(app.views_list, function (prop, value, parent) {
-            if (prop == 'view_id' || prop == 'container_id') {
+        this._crawling(app.views_list, (prop, value, parent) => {
+            if (prop === 'view_id' || prop === 'container_id') {
                 parent[prop] = 0;
             }
-        })
+        });
     }
 
-    connectApps(apps, appsConnectingMap, source_apps) {
-        const self = this;
+    // Reconnects all internal references (fields, apps, views, triggers) after cloning
+    _connectApps(apps, appsConnectingMap, source_apps) {
+        const hasProp = (prop, propArray) => propArray.some(key => prop.indexOf(key) !== -1);
 
-        apps.forEach(app => {
-            appsConnectingMap.apps.forEach(appMap => {
+        for (const app of apps) {
+            for (const appMap of appsConnectingMap.apps) {
                 if (app.view_init === appMap.new_view_init) {
-                    appsConnectingMap.views.forEach(view => {
+                    for (const view of appsConnectingMap.views) {
                         if (appMap.old_view_init === view.old_view_id) {
                             app.view_init = view.new_view_id;
                         }
-                    })
+                    }
                 }
-            });
-
-            self.crawling(app.field_list, function (prop, value, parent) {
-                const fieldProps = ["field_id", "FieldId", "destination_field", "element_id"];
-                const appProps = ["app_id", "AppId", "destination_app"];
-                const viewProps = ["view_id"];
-                const srcProps = ["src"];
+            }
 
-                const hasProp = (prop, propArray) => propArray.some(key => prop.indexOf(key) !== -1);
+            this._crawling(app.field_list, (prop, value, parent) => {
+                const fieldProps = ['field_id', 'FieldId', 'destination_field', 'element_id'];
+                const appProps = ['app_id', 'AppId', 'destination_app'];
+                const viewProps = ['view_id'];
+                const srcProps = ['src'];
 
                 if (hasProp(prop, fieldProps)) {
-                    let fieldsArr = String(value).split(','), newFieldsArr = [];
+                    const fieldsArr = String(value).split(',');
+                    const newFieldsArr = [];
 
-                    appsConnectingMap.fields.forEach(field => {
-                        fieldsArr.forEach(fieldFromValue => {
+                    for (const field of appsConnectingMap.fields) {
+                        for (const fieldFromValue of fieldsArr) {
                             if (fieldFromValue == field.old_field_id) {
                                 newFieldsArr.push(field.new_field_id);
                             }
-                        })
-                    })
-
-                    if (newFieldsArr.length) {
-                        parent[prop] = newFieldsArr.join(',');
+                        }
                     }
+
+                    if (newFieldsArr.length) parent[prop] = newFieldsArr.join(',');
                 }
 
                 if (hasProp(prop, appProps)) {
-                    appsConnectingMap.apps.forEach(app => {
-                        if (value == app.old_app_id) {
-                            parent[prop] = app.new_app_id;
-                        }
-                    })
+                    for (const appMap of appsConnectingMap.apps) {
+                        if (value == appMap.old_app_id) parent[prop] = appMap.new_app_id;
+                    }
                 }
 
                 if (hasProp(prop, viewProps)) {
-                    appsConnectingMap.views.forEach(view => {
-                        if (value == view.old_view_id) {
-                            parent[prop] = view.new_view_id;
-                        }
-                    })
+                    for (const view of appsConnectingMap.views) {
+                        if (value == view.old_view_id) parent[prop] = view.new_view_id;
+                    }
                 }
 
                 if (hasProp(prop, srcProps) && isFinite(value)) {
                     const pron_name = 'container_id';
                     const old_app_id = appsConnectingMap.apps.find(appMap => appMap.new_app_id === app.app_id).old_app_id;
-                    const path = self.findPath(source_apps[old_app_id].views_list, pron_name, value);
-
-                    parent[prop] = `${self.getValueByPath(app.views_list, path, pron_name)}`;
+                    const path = this._findPath(source_apps[old_app_id].views_list, pron_name, value);
+                    parent[prop] = `${this._getValueByPath(app.views_list, path, pron_name)}`;
                 }
 
-                if (prop.indexOf("trigger") !== -1 && value.model && value.model.nodes) {
+                // Trigger nodes keep field IDs as object keys, so we need to remap both keys and connections.
+                if (prop.indexOf('trigger') !== -1 && value.model?.nodes) {
                     const nodes = value.model.nodes;
-                    const nodeProperties = ["inputs", "outputs"];
 
                     for (const index in nodes) {
-                        nodeProperties.forEach((property) => {
+                        for (const property of ['inputs', 'outputs']) {
                             const node = nodes[index];
-                            const numericProperties = Object.keys(node[property]).filter(prop => prop !== '' && !isNaN(prop)); // field_id as keys
-
-                            numericProperties.forEach((old_field_id) => {
-                                const correspondFieldOfConnectingMap = appsConnectingMap.fields.filter((field) => field.old_field_id == old_field_id);
+                            const numericProperties = Object.keys(node[property]).filter(p => p !== '' && !isNaN(p));
 
-                                if (correspondFieldOfConnectingMap.length !== 0 && correspondFieldOfConnectingMap[0].new_field_id) {
-                                    const new_field_id = correspondFieldOfConnectingMap[0].new_field_id.toString();
+                            for (const old_field_id of numericProperties) {
+                                const match = appsConnectingMap.fields.find(f => f.old_field_id == old_field_id);
 
+                                if (match?.new_field_id) {
+                                    const new_field_id = match.new_field_id.toString();
                                     const connectionObjectCopy = node[property][old_field_id];
-                                    connectionObjectCopy.connections.forEach((connection) => {
-                                        if (connection.input == old_field_id) {
-                                            connection.input = new_field_id;
-                                        }
-                                        if (connection.output == old_field_id) {
-                                            connection.output = new_field_id;
-                                        }
-                                    });
 
-                                    delete node[property][old_field_id];
+                                    for (const connection of connectionObjectCopy.connections) {
+                                        if (connection.input == old_field_id) connection.input = new_field_id;
+                                        if (connection.output == old_field_id) connection.output = new_field_id;
+                                    }
 
+                                    delete node[property][old_field_id];
                                     node[property][new_field_id] = connectionObjectCopy;
                                 }
-                            });
-                        });
-                    };
+                            }
+                        }
+                    }
                 }
-            })
-        })
+            });
+        }
 
         return apps;
     }
 
-    getValueByPath(source, path, prop) {
+    // Utility to safely access nested value by path
+    _getValueByPath(source, path, prop) {
         let temp = source;
-
-        path.split('.').forEach(item => {
+        for (const item of path.split('.')) {
             temp = temp[item];
-        })
-
+        }
         return temp[prop];
     }
 
-    findPath(source, prop, value) {
-        const self = this;
-
+    // Finds path to a specific value inside deeply nested structure
+    _findPath(source, prop, value) {
         let isFound = false;
         let toClearPath = false;
         let path = [];
 
-        self.crawling(source, function (propSource, valueSource, parentSource) {
+        this._crawling(source, (propSource, valueSource, parentSource) => {
             if (toClearPath) {
                 path.reverse().forEach(item => {
                     if (toClearPath) {
                         item.delete = true;
-
                         if (item.parent === parentSource) {
                             toClearPath = false;
                             path = path.filter(item => !item.delete);
                             path.reverse();
                         }
                     }
-                })
+                });
             }
 
             if (!isFound) {
                 if (typeof parentSource[propSource] === 'object') {
-                    path.push({
-                        prop: propSource,
-                        parent: parentSource
-                    });
+                    path.push({ prop: propSource, parent: parentSource });
                 }
 
                 if (valueSource == value && prop === propSource) {
@@ -580,24 +527,23 @@ export default class AppsTemplateService {
         return path.map(item => item.prop).join('.');
     }
 
-    prepareAppTemplate(appToTemplate) {
-        const self = this;
+    // Prepares clean app template by stripping IDs and resetting system fields
+    _prepareAppTemplate(appToTemplate) {
+        const app = JSON.parse(JSON.stringify(appToTemplate));
 
-        let app = JSON.parse(JSON.stringify(appToTemplate));
-
-        self.crawling(app.views_list, function (prop, value, parent) {
-            if (prop == "element_id") {
+        this._crawling(app.views_list, (prop, value, parent) => {
+            if (prop === 'element_id') {
                 parent.element_id = -Number(value);
                 parent.create_element = -Number(value);
             }
-        })
+        });
 
-        app.field_list.forEach(field => {
+        for (const field of app.field_list) {
             field.create_field = -Number(field.field_id);
             field.element_id = -Number(field.field_id);
             field.field_id = -Number(field.field_id);
-            field.field_value = ""; /* Should be removed when we update createApp API*/
-        })
+            field.field_value = '';
+        }
 
         app.items_list = [];
 
@@ -609,6 +555,5 @@ export default class AppsTemplateService {
         delete app.file_list;
 
         return app;
-    };
-
-}
+    }
+}