@gudhub/core 1.0.68 → 1.1.2

package/GUDHUB/Utils/AppsTemplateService/AppsTemplateService.js

@@ -0,0 +1,526 @@
+export default class AppsTemplateService {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+        this.appsConnectingMap = {
+            apps: [],
+            fields: [],
+            items: [],
+            views: []
+        }
+    }
+
+    createAppsFromTemplate(pack, maxNumberOfInsstalledItems, progressCallback) {
+        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.call(this, {
+                    percent: currentStep * stepPercents,
+                    status
+                })
+            }).then(success => {
+                self.createItems(success, maxNumberOfInsstalledItems, (status) => {
+                    if(typeof status === 'string') {
+                        currentStep += 1;
+                        progressCallback.call(this, {
+                            percent: currentStep * stepPercents,
+                            status
+                        })
+                    } else if (typeof status === 'object') {
+                        progressCallback.call(this, {
+                            status: 'Done',
+                            apps: status
+                        })
+                    }
+                }).then(() => {
+                    resolve();
+                })
+            })
+        });
+    }
+
+    createItems(create_apps, maxNumberOfInsstalledItems, callback) {
+        return new Promise(resolve => {
+            const MAX_NUMBER_OF_INSTALLED_ITEMS = maxNumberOfInsstalledItems ? maxNumberOfInsstalledItems : 100000;
+            const self = this;
+            let createsItems = [];
+            let promises = [];
+
+            create_apps.forEach(app => {
+                promises.push(new Promise(app_resolve => {
+                self.gudhub.getApp(self._searchOldAppId(app.app_id, self.appsConnectingMap.apps)).then(result_app => {
+                    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;
+
+                        if(items.length === 0) {
+                            callback ? callback.call(this, `NO ITEMS TO REPLACE VALUE: ${result_app.app_name} (Items steps)`) : null;
+                            app_resolve();
+                        }
+
+                        app.items_list = items;
+                        self._updateMap(app.items_list, source_app.items_list);
+                        self._addFieldValue(source_app.items_list, app.items_list, self.appsConnectingMap);
+
+                        createsItems.push(app);
+
+                        if (self.appsConnectingMap.apps.length === createsItems.length) {
+                            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;
+                                            }
+                                        })
+                                    })
+                                })
+                            });
+
+                            self.deleteField(createsItems);
+
+                            self.replaceValue(createsItems, self.appsConnectingMap).then(() => {
+                                callback ? callback.call(this, `REPLACE VALUE: ${result_app.app_name} (Items steps)`) : null;
+                                createsItems.forEach(created_app => {
+                                    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(() => {
+                                        app_resolve();
+                                    })
+                                })
+                            });
+                        }
+                    });
+                });
+            }));
+        });
+
+            Promise.all(promises).then(() => {
+                let apps = create_apps.map(app => {
+                    return app.app_id;
+                });
+                callback.call(this, apps);
+                resolve();
+            })
+        })
+    }
+
+    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;
+                })
+            })
+        })
+    }
+
+    replaceValue(apps, map) {
+        return new Promise(async (resolve) => {
+            const allPromises = [];
+            const self = this;
+
+            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);
+                    }
+
+                    allPromises.push(self.gudhub.ghconstructor.getInstance(field_of_list.data_type).then(data => {
+                        if (data.getTemplate().constructor == 'file') {
+                            return self.gudhub.util.fileInstallerHelper(app.app_id, app.items_list, field_of_list.field_id).then(result => {
+                                return result;
+                            });
+                        } else if (data.getTemplate().constructor == 'document') {
+                            self.documentInstallerHelper(app.app_id, app.items_list, field_of_list.field_id).then(result => {
+                                return data;
+                            })
+                        } else {
+                            return data;
+                        }
+                    }))
+
+                })
+            });
+
+            if(allPromises.length > 0) {
+
+                Promise.all(allPromises).then(result => {
+                    resolve(result);
+                });
+
+            } else {
+                resolve(result);
+            }
+
+        });
+    }
+
+    documentInstallerHelper(appId, items, elementId) {
+        const self = this;
+        return new Promise(async (resolve) => {
+            items.forEach(item => {
+                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) {
+                    self.gudhub.getDocument({
+                        _id: field.field_value
+                    }).then(document => {
+                        self.gudhub.createDocument({
+                            app_id: appId,
+                            item_id: itemId,
+                            element_id: elementId,
+                            data: document.data
+                        }).then(new_document => {
+                            field.field_value = new_document._id;
+                            resolve();
+                        })
+                    })
+                }
+            });
+        });
+    }
+
+    _replaceValueItemRef(app, field_of_list, map) {
+        app.items_list.forEach(item => {
+            item.fields.forEach(field_of_item => {
+                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;
+                            }
+                        });
+
+                        map.items.forEach(item_ids => {
+                            if (value[1] == item_ids.old_item_id) {
+                                value[1] = item_ids.new_item_id;
+                            }
+                        });
+
+                        arr_values[key] = value.join('.')
+
+                    });
+
+                    field_of_item.field_value = arr_values.join(',');
+
+                }
+            });
+        })
+    }
+
+    _addFieldValue(source_app_items, create_items, appsConnectingMap) {
+        create_items.forEach(new_item => {
+            appsConnectingMap.items.forEach(item_of_map => {
+                if (new_item.item_id === item_of_map.new_item_id) {
+                    source_app_items.forEach(old_item => {
+                        if (item_of_map.old_item_id === old_item.item_id) {
+                            new_item.fields = old_item.fields;
+                        }
+                    })
+                }
+            })
+        })
+    }
+
+    _updateMap(new_items, old_items) {
+        old_items.forEach(old_item => {
+            new_items.forEach(new_item => {
+                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) {
+        const self = this;
+
+        let progress = {
+            step_size: 100 / (pack.apps.length * 3),
+            apps: []
+        }
+
+        return new Promise(resolve => {
+            let source_apps = {};
+            let created_apps = [];
+            let updated_apps = [];
+
+            pack.apps.forEach(app_id => {
+                self.gudhub.getApp(app_id).then(result_app => {
+                    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 + ' New';
+                    appTemplate.privacy = 1;
+                    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);
+                                    }
+                                })
+                            })
+                        }
+                    });
+                })
+            })
+        });
+    }
+
+    mapApp(base_app, new_app, appsConnectingMap) {
+        appsConnectingMap.apps.push({
+            old_app_id: base_app.app_id,
+            new_app_id: new_app.app_id,
+            old_view_init: base_app.view_init,
+            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) {
+                    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) {
+                    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;
+
+        if (properties.length > 0) {
+            properties.forEach(prop => {
+                let propertyValue = object[prop];
+
+                if (propertyValue && typeof object != 'string') {
+                    action(prop, propertyValue, object);
+                    self.crawling(propertyValue, action);
+                }
+            })
+        }
+    }
+
+    resetViewsIds(app) {
+        app.view_init = 0;
+
+        this.crawling(app.views_list, function (prop, value, parent) {
+            if (prop == 'view_id' || prop == 'container_id') {
+                parent[prop] = 0;
+            }
+        })
+    }
+
+    connectApps(apps, appsConnectingMap, source_apps) {
+        const self = this;
+
+        apps.forEach(app => {
+            appsConnectingMap.apps.forEach(appMap => {
+                if (app.view_init === appMap.new_view_init) {
+                    appsConnectingMap.views.forEach(view => {
+                        if (appMap.old_view_init === view.old_view_init) {
+                            app.view_init = view.new_view_id;
+                        }
+                    })
+                }
+            });
+
+            self.crawling(app.field_list, function (prop, value, parent) {
+                if (prop.indexOf("field_id") !== -1 || prop.indexOf("FieldId") !== -1 || prop.indexOf("destination_field") !== -1) {
+                    let fieldsArr = String(value).split(','), newFieldsArr = [];
+
+                    appsConnectingMap.fields.forEach(field => {
+                        fieldsArr.forEach(fieldFromValue => {
+                            if (fieldFromValue == field.old_field_id) {
+                                newFieldsArr.push(field.new_field_id);
+                            }
+                        })
+                    })
+
+                    if (newFieldsArr.length) {
+                        parent[prop] = newFieldsArr.join(',');
+                    }
+                }
+
+                if (prop.indexOf("app_id") != -1 || prop.indexOf("AppId") != -1 || prop.indexOf("destination_app") != -1) {
+                    appsConnectingMap.apps.forEach(app => {
+                        if (value == app.old_app_id) {
+                            parent[prop] = app.new_app_id;
+                        }
+                    })
+                }
+
+                if (prop.indexOf("view_id") !== -1) {
+                    appsConnectingMap.views.forEach(view => {
+                        if (value == view.old_view_id) {
+                            parent[prop] = view.new_view_id;
+                        }
+                    })
+                }
+
+                if (prop.indexOf("src") !== -1 && 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)}`;
+                }
+
+            })
+        })
+
+        return apps;
+    }
+
+    getValueByPath(source, path, prop) {
+        let temp = source;
+
+        path.split('.').forEach(item => {
+            temp = temp[item];
+        })
+
+        return temp[prop];
+    }
+
+    findPath(source, prop, value) {
+        const self = this;
+
+        let isFound = false;
+        let toClearPath = false;
+        let path = [];
+
+        self.crawling(source, function (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
+                    });
+                }
+
+                if (valueSource == value && prop === propSource) {
+                    isFound = true;
+                } else if (Object.keys(parentSource).pop() === propSource && typeof parentSource[propSource] !== 'object') {
+                    toClearPath = true;
+                }
+            }
+        });
+
+        return path.map(item => item.prop).join('.');
+    }
+
+    prepareAppTemplate(appToTemplate) {
+        const self = this;
+
+        let app = JSON.parse(JSON.stringify(appToTemplate));
+
+        self.crawling(app.views_list, function (prop, value, parent) {
+            if (prop == "element_id") {
+                parent.element_id = -Number(value);
+                parent.create_element = -Number(value);
+            }
+        })
+
+        app.field_list.forEach(field => {
+            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*/
+        })
+
+        app.items_list = [];
+
+        delete app.app_id;
+        delete app.icon.id;
+        delete app.group_id;
+        delete app.trash;
+        delete app.last_update;
+        delete app.file_list;
+
+        return app;
+    };
+
+}

package/GUDHUB/Utils/FIleHelper/FileHelper.js

@@ -0,0 +1,69 @@
+export class FileHelper {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+    }
+
+    fileInstallerHelper(appId, items, elementId) {
+        const self = this;
+        return new Promise(resolve => {
+            const files = [[]];
+            let chainPromises = Promise.resolve();
+            let results = [];
+
+            items.forEach(item => {
+                const itemId = item.item_id;
+                const field = item.fields.find(field => field.element_id === elementId);
+
+                if(field && field.field_value) {
+                    const fileIds = field.field_value.split('.');
+
+                    fileIds.forEach(fileId => {
+                        const newFile = {
+                            source: fileId,
+                            destination: {
+                                app_id: appId,
+                                item_id: itemId,
+                                element_id: elementId
+                            }
+                        }
+
+                        if(files[files.length - 1].length !== 10) { // 10 - max duplicate files
+                            files[files.length - 1].push(newFile);
+                        } else {
+                            files.push([newFile]);
+                        }
+                    })
+                }
+            });
+
+            files.forEach(filePack => {
+                chainPromises = chainPromises.then(() => {
+                    return self.gudhub.duplicateFile(filePack);
+                }).then(result => {
+                    results = [
+                        ...results,
+                        ...result
+                    ]
+                })
+            });
+
+            chainPromises.then(() => {
+                items.forEach(item => {
+                    const itemId = item.item_id;
+                    const field = item.fields.find(field => field.element_id === elementId);
+
+                    if(field && field.field_value) {
+                        field.field_value = '';
+                        results.forEach(file => {
+                            if(file.item_id === itemId) {
+                                field.field_value = field.field_value.split(',').filter(fileId => fileId).concat(file.file_id).join(',');
+                            }
+                        })
+                    }
+                })
+
+                resolve();
+            })
+        });
+    }
+}

package/GUDHUB/Utils/MergeFields/MergeFields.js

@@ -117,6 +117,8 @@ export default class FieldsOperator {
 
             let actualFieldIds = fieldList.map((field) => +field.field_id);
 
+            const promises = [];
+
             columnsToView = fieldList.reduce((viewColumsList, currentField) => {
                 let field = viewColumsList.find((view, index) => {
                     if (currentField.field_id == view.field_id) {
@@ -126,21 +128,28 @@ export default class FieldsOperator {
                 });
 
                 if (!field) {
-                    this.gudhub.ghconstructor.getInstance(currentField.data_type).then(instance => {
-                        let template = instance.getTemplate();
-                        let defaultIntepretation = template.model.data_model.interpretation.find((intrpr) => intrpr.src == 'table') || { settings: { show_field: 1 } };
-                        viewColumsList.push({
-                            field_id: currentField.field_id,
-                            data_type: currentField.data_type,
-                            show: defaultIntepretation.settings.show_field
-                        });
-                    })
+
+                    viewColumsList.push({
+                        field_id: currentField.field_id,
+                        data_type: currentField.data_type,
+                    });
+
+                    promises.push(new Promise(async (resolve) => {
+                        const instance = await this.gudhub.ghconstructor.getInstance(currentField.data_type);
+                        const template = instance.getTemplate();
+                        const defaultIntepretation = template.model.data_model.interpretation.find((intrpr) => intrpr.src == 'table') || { settings: { show_field: 1 } };
+                        viewColumsList.find(view => view.field_id == currentField.field_id).show = defaultIntepretation.settings.show_field;
+                        resolve(true);
+                    }));
                 }
 
                 return viewColumsList;
-            }, tableSettingsFieldListToView).filter((field) => actualFieldIds.indexOf(field.field_id) != -1);
+            }, tableSettingsFieldListToView);
 
-            resolve(columnsToView);
+            Promise.all(promises).then(() => {
+                columnsToView = columnsToView.filter((field) => actualFieldIds.indexOf(field.field_id) != -1);
+                resolve(columnsToView)
+            })
         })
     }
 }

package/GUDHUB/Utils/Utils.js

@@ -19,12 +19,16 @@ import ItemsSelection from "./ItemsSelection/ItemsSelection.js";
 
 import { compare_items_lists_Worker } from "./compare_items_lists_worker/compare_items_lists.worker.js";
 import { compiler } from "./json_constructor/json_constructor.js";
+import AppsTemplateService from "./AppsTemplateService/AppsTemplateService.js";
+import { FileHelper } from "./FIleHelper/FileHelper.js";
 
 export class Utils {
   constructor(gudhub) {
     this.gudhub = gudhub;
     this.MergeFields = new MergeFields(gudhub);
     this.ItemsSelection = new ItemsSelection(gudhub);
+    this.AppsTemplateService = new AppsTemplateService(gudhub);
+    this.FileHelper = new FileHelper(gudhub);
   }
 
   prefilter(filters_list, element_app_id, app_id, item_id, variables = []) {
@@ -174,6 +178,22 @@ export class Utils {
   jsonConstructor(scheme, item, variables){
     return compiler(scheme, item, this, variables)
   }
+
+  fileInstallerHelper(appId, items, elementId) {
+    return this.FileHelper.fileInstallerHelper(appId, items, elementId);
+  }
+
+  createAppsFromTemplate(pack, maxNumberOfInsstalledItems, progressCallback) {
+    return this.AppsTemplateService.createAppsFromTemplate(pack, maxNumberOfInsstalledItems, progressCallback);
+  }
+
+  createApps(pack) {
+    return this.AppsTemplateService.createApps(pack);
+  }
+
+  createItems(create_apps, maxNumberOfInsstalledItems) {
+    return this.AppsTemplateService.createItems(create_apps, maxNumberOfInsstalledItems);
+  }
   
   compareAppsItemsLists(items_list1, items_list2, callback) {
     const chunkWorkerBlob = new Blob([compare_items_lists_Worker()], {