@gudhub/core 1.0.57 → 1.0.61

package/GUDHUB/GHConstructor/ghconstructor.js

@@ -11,6 +11,57 @@ let $q = {
     }
 }
 
+/*************** FAKE ANGULAR ***************/
+// It's needed when we eval() angular code.
+
+let factoryReturns = {};
+
+let angular = {
+    module() {
+        return angular;
+    },
+    directive() {
+        return angular;
+    },
+    factory(name, args) {
+        try {
+            if(typeof args === 'object') {
+                factoryReturns[name] = args[args.length - 1]($q);
+            } else {
+                factoryReturns[name] = args($q);
+            }
+        } catch(error) {
+            console.log('Errror in data type: ', name);
+            console.log(error);
+        }
+        return angular;
+    },
+    service() {
+        return angular;
+    },
+    run() {
+        return angular;
+    },
+    filter() {
+        return angular;
+    },
+    controller() {
+        return angular;
+    },
+    value() {
+        return angular;
+    },
+    element() {
+        return angular;
+    },
+    injector() {
+        return angular;
+    },
+    invoke() {
+        return angular;
+    }
+}
+
 export class GHConstructor {
     constructor() {
         this.cache = [];
@@ -23,7 +74,7 @@ export class GHConstructor {
     // If not, check if module is in cache. If not, create new instance and put loading to modules query.
     // If yes, return module from cache.
 
-    getInstance(module_id) {
+    async getInstance(module_id) {
         return new Promise(async (resolve) => {
             if (this.modulesQueue[module_id]) {
                 return this.modulesQueue[module_id].then(() => {
@@ -64,8 +115,8 @@ export class GHConstructor {
 
     /*************** CREATE INSTANCE ***************/
     // Get angular module and module's code.
-    // Then parsing module's code.
-    // Finally, creating instance of module, using functions from angular module and parsed code.
+    // Then eval() module's code.
+    // Finally, creating instance of module, using functions from angular module and evaled code.
 
     async createInstance(module_id) {
         let module_url = gudhub.storage.getModuleUrl(module_id);
@@ -78,13 +129,11 @@ export class GHConstructor {
 
         let module = await axios.get(module_url);
         module = module.data;
-        let returningObject = this.parseModule(module, module_id);
-        if(!returningObject) return false;
-        let obj;
+
         try {
-            eval('obj = ' + returningObject);
+            eval(module);
         } catch(error) {
-            console.log(`Error in ghconstructor (${module_id})`, error);
+            console.error('ERROR WHILE EVAL() IN GHCONSTRUCTOR', error);
         }
 
         let result = {
@@ -141,7 +190,7 @@ export class GHConstructor {
 
             getInterpretation: function (value, field, dataType, interpretation_id, itemId, appId) {
                 return new Promise(async (resolve) => {
-                    let currentDataType = obj;
+                    let currentDataType = angularModule;
 
                     let interpr_arr = await currentDataType.getInterpretation(value, field, dataType, interpretation_id, itemId, appId);
                     if (interpr_arr) {
@@ -158,17 +207,36 @@ export class GHConstructor {
                 });
             },
 
+            //*************** GET INTERPRETATION V2 ****************//
+
+            getInterpretationNew: function(value, interpretation_id, dataType, field, itemId, appId) {
+                return new Promise(async (resolve) => {
+                    let currentDataType = factoryReturns[module_id];
+
+                    try {
+                        let interpr_arr = await currentDataType.getInterpretationNew(value, appId, itemId, field, dataType);
+                        let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
+
+                        let result = await data.content()
+
+                        resolve({ html: result });
+                    } catch(error) {
+                        console.log(`ERROR IN ${module_id}`, error);
+                        resolve({ html: '<span>no interpretation</span>' })
+                    }
+                });
+            },
+
             //*************** GET INTERPRETATED VALUE ****************//
 
             getInterpretatedValue: function (field_value, field_model, appId, itemId) {
                 return new Promise(async (resolve) => {
-                    let getInterpretatedValueFunction = angularModule.getInterpretatedValue;
+                    let getInterpretatedValueFunction = factoryReturns[module_id].getInterpretatedValue;
                     if (getInterpretatedValueFunction) {
                         let value = await getInterpretatedValueFunction(field_value, field_model, appId, itemId);
                         resolve(value);
                     } else {
-                        let value = await gudhub.getFieldValue(appId, itemId, field_model.id);
-                        resolve(value);
+                        resolve(field_value);
                     }
                 });
             },
@@ -206,43 +274,4 @@ export class GHConstructor {
 
         return result;
     }
-
-    /*************** PARSE MODULE ***************/
-    // Firstly, it's find factory with provided name.
-    // Then it's parsing factory's code, by counting open and closed brackets.
-    // Then returns object, which originally must be returned by factory.
-
-    parseModule(module, module_id) {
-        let factoryStart = module.indexOf(`.factory('${module_id}',`);
-        if(factoryStart === -1) {
-            factoryStart = module.indexOf(`.factory("${module_id}",`);
-        }
-        if(factoryStart !== -1) {
-            let factory = module.substring(factoryStart, module.length);
-            let returnStart = factory.indexOf('return');
-            let returningObject = factory.substring(returnStart, factory.length);
-            let firstBracket = returningObject.indexOf('{');
-            returningObject = returningObject.substring(firstBracket, returningObject.length);
-            let openBrackets = 0;
-            let closeBrackets = 0;
-            let returnEnd = 0;
-            for (let i = 0; i < returningObject.length; i++) {
-                if (returningObject[i] === '{') {
-                    openBrackets++;
-                }
-                if (returningObject[i] === '}') {
-                    closeBrackets++;
-                }
-                if (openBrackets === closeBrackets && i >= firstBracket) {
-                    returnEnd = i;
-                    break;
-                }
-            }
-            returningObject = returningObject.substring(0, returnEnd + 1);
-            return returningObject;
-        } else {
-            return false;
-        }
-    }
-
 }

package/GUDHUB/GHConstructor/interpritate.js

@@ -0,0 +1,93 @@
+export class Interpritate {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+    }
+
+    /*********************** GET INTERPRETATION OBJ ***********************/
+
+    getInterpretationObj(fieldDataModel, defaultFieldDataModel, src, containerId) {
+        var currentIntrpr = {};
+
+        var defaultIntrprObj = defaultFieldDataModel.data_model.interpretation.find(function (interpritation) {
+            return interpritation.src == src;
+        }) || defaultFieldDataModel.data_model.interpretation.find(function (interpritation) {
+            return interpritation.src == 'table';
+        }) || { id: 'default' };
+
+        if (fieldDataModel.data_model && fieldDataModel.data_model.interpretation) {
+            // To detect interpretation we use (container_id), if there is not (container_id) we use (src)
+            currentIntrpr = fieldDataModel.data_model.interpretation.find(function (interpritation) {
+                return interpritation.src == containerId;
+            }) || fieldDataModel.data_model.interpretation.find(function (interpritation) {
+                return interpritation.src == src;
+            });
+        }
+        return gudhub.mergeObjects(defaultIntrprObj, currentIntrpr);
+    }
+
+    /*********************** GET INTERPRETATION ***********************/
+
+    getInterpretation(value, field, dataType, source, itemId, appId, containerId) {
+        const self = this;
+        return new Promise(async (resolve, reject) => {
+            /*-- By default we use 'data_type' from field but in case if field is undefined we use 'dataType' from attribute*/
+            var data_type = field && field.data_type ? field.data_type : dataType;
+
+            /*---- Constructing Data Object ----*/
+            if (data_type) {
+                /*-- if we have data_type then we construct new data object to interpritate value*/
+                gudhub.ghconstructor.getInstance(data_type).then(function (data) {
+                    var interpretationObj = self.getInterpretationObj(field, data.getTemplate().model, source, containerId);
+                    data.getInterpretationNew(value, interpretationObj.id, data_type, field, itemId, appId).then(function (result) {
+                        // console.log(result, interpretationObj)
+
+                        resolve(gudhub.mergeObjects(result, interpretationObj));
+                    }, function (error) {
+                        reject();
+                    });
+                }, function (error) { });
+
+            } else {
+                /*-- if we don't have data_type then we run defaultInterpretation function*/
+                resolve(this.getDefaultInterpretation(value, field));
+            }
+        });
+    }
+
+    /*********************** GET DEFAULT INTERPRETATION ***********************/
+
+    getDefaultInterpretation(value, options) {
+        var result = value;
+  
+        if (options) {
+          /*-- Iterating through options from data_model to find a nave for selected*/
+          options.forEach(item => {
+              if(item.value == value && value != '') {
+                  result = item.name;
+              }
+          })
+        }
+        return result;
+      }
+
+    /********************* GET INTERPRETATION BY ID *********************/
+
+    getInterpretationById(appId, itemId, fieldId, interpretationId) {
+        return new Promise(async (resolve) => {
+            let fieldValue = await this.gudhub.getFieldValue(appId, itemId, fieldId);
+            let fieldModel = await this.gudhub.getField(appId, fieldId);
+            if(fieldModel == null) {
+                resolve('');
+            }
+            this.gudhub.ghconstructor.getInstance(fieldModel.data_type).then(async (instance) => {
+                let interpretatedValue = await instance.getInterpretationNew(fieldValue, interpretationId, fieldModel.data_type, fieldModel, itemId, appId);
+                if(interpretatedValue.html == '<span>no interpretation</span>') {
+                    resolve(fieldValue);
+                } else {
+                    resolve(interpretatedValue.html);
+                }
+            });
+        });
+    }
+
+}

package/GUDHUB/Storage/ModulesList.js

@@ -405,5 +405,9 @@ export default function generateModulesList(async_modules_path, file_server_url)
             name: "vs_code",
             url: file_server_url + '/' + async_modules_path + "vs_code_data.js"
         },
+        {
+            name: "nested_list",
+            url: file_server_url + '/' + async_modules_path + "nested_list_data.js"
+        },
     ]
 }

package/GUDHUB/Storage/Storage.js

@@ -6,6 +6,7 @@ export class Storage {
     this.users_list = [];
     this.user = {};
     this.modulesList = generateModulesList(async_modules_path, file_server_url);
+    this.ghComponentsPromises = [];
   }
 
   getMainStorage() {

package/GUDHUB/Utils/ItemsSelection/ItemsSelection.js

@@ -0,0 +1,52 @@
+export default class ItemsSelection {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+        this.selectedItems = {}
+    }
+
+    async selectItems(appId, items) {
+        if(!this.selectedItems.hasOwnProperty(appId)) {
+            this.selectedItems[appId] = {
+                items: [],
+                app: []
+            }
+
+            let app = await this.gudhub.getApp(appId);
+            this.selectedItems[appId].app = app;
+        }
+
+        let itemObject = this.selectedItems[appId];
+
+        let selectedItemsIds = itemObject.items.map(obj => obj.item_id);
+
+        items.forEach(item => {
+            if(selectedItemsIds.indexOf(item.item_id) != -1) {
+                itemObject.items.splice(selectedItemsIds.indexOf(item.item_id), 1);
+            } else {
+                itemObject.items[itemObject.items.length] = item;
+            }
+        });
+
+    }
+
+    getSelectedItems(appId) {
+        return this.selectedItems[appId] ? this.selectedItems[appId] : { items: [], app: [] };
+    }
+
+    clearSelectedItems(appId) {
+        if(this.selectedItems[appId]) {
+            this.selectedItems[appId].items = [];
+        }
+    }
+
+    isItemSelected(appId, itemId) {
+        let array = this.getSelectedItems(appId);
+        if(array !== null) {
+            array = array.items.map(obj => obj.item_id);
+            return array.indexOf(itemId) != -1;
+        } else {
+            return false;
+        }
+    }
+
+}

package/GUDHUB/Utils/ItemsSelection/ItemsSelection.test.js

@@ -0,0 +1,62 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+describe("ITEMS SELECTION", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    const appId = 16259;
+
+    const items = [
+        {
+            "item_id": 1,
+            "last_update": 1123669745123,
+            "fields": []
+        },
+        {
+            "item_id": 2,
+            "last_update": 1985625103278,
+            "fields": []
+        },
+        {
+            "item_id": 3,
+            "last_update": 1614725478960,
+            "fields": []
+        },
+    ]
+
+    // ORDER OF TEST IS IMPORTANT!
+
+    it('SELECT AND GET SELECTED ITEM', async function() {
+        await gudhub.util.selectItems(appId, [items[0]]);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(1);
+    });
+
+    it('CHECK IF ITEM SELECTED', async function() {
+        let isItemSelected = gudhub.util.isItemSelected(appId, 1);
+        isItemSelected.should.equals(true);
+
+        isItemSelected = gudhub.util.isItemSelected(appId, 2);
+        isItemSelected.should.equals(false);
+    });
+
+    it('CLEAR SELECTED ITEMS', async function() {
+        gudhub.util.clearSelectedItems(appId);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(0);
+    });
+
+    it('SELECT MULTIPLE ITEMS', async function() {
+        await gudhub.util.selectItems(appId, items);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(3);
+    })
+
+});

package/GUDHUB/Utils/MergeFields/MergeFields.js

@@ -0,0 +1,147 @@
+export default class FieldsOperator {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+    }
+
+    mergeFieldLists(fieldsToView, fieldList) {
+        let fieldsToViewCopy = JSON.parse(JSON.stringify(fieldsToView));
+        let fieldListCopy = JSON.parse(JSON.stringify(fieldList));
+
+        let existingFieldsIds = fieldListCopy.map(field => field.field_id);
+
+        if (!fieldListCopy.length) {
+            return [];
+        }
+
+        return fieldListCopy.reduce((viewArray, currentField) => {
+
+            let positionInViewArray = null;
+            let props = viewArray.find((view, index) => {
+                if (currentField.field_id == view.field_id) {
+                    positionInViewArray = index;
+                    return true;
+                }
+                return false;
+            });
+
+            if (!props) {
+
+                let defaultIntrpr = currentField.data_model && currentField.data_model.interpretation ? currentField.data_model.interpretation.find((intrpr) => {
+                    return intrpr.src == 'table';
+                }) || { settings: { show_field: 1 } } : { settings: { show_field: 1 } };
+
+                if (defaultIntrpr.settings.show_field) {
+                    let firstMerge = this.gudhub.util.mergeObjects({ show: 1 }, defaultIntrpr);
+                    let secondMerge = this.gudhub.util.mergeObjects(firstMerge, currentField);
+                    viewArray.push(secondMerge);
+                }
+
+            } else {
+                viewArray[positionInViewArray] = this.gudhub.util.mergeObjects(viewArray[positionInViewArray], currentField);
+            }
+
+            return viewArray;
+        }, fieldsToViewCopy).filter(function (field) {
+            return field.show && existingFieldsIds.indexOf(field.field_id) != -1;
+        });
+    };
+
+    createFieldsListToView(appId, tableSettingsFieldListToView) {
+        console.log('YA YA YA');
+        const self = this;
+        return new Promise(async (resolve) => {
+            let fieldList = await this.gudhub.getFieldModels(appId);
+
+            if (tableSettingsFieldListToView.length !== 0) {
+                let correctFieldList = [];
+                tableSettingsFieldListToView.forEach((elementFromTable, index) => {
+                    let fieldOnPipe = fieldList.find((element) => elementFromTable.field_id == element.field_id);
+
+                    if (fieldOnPipe) {
+                        let show_field = fieldOnPipe.data_model.interpretation.find((intrpr) => intrpr.src == 'table');
+                        if (!show_field) {
+                            show_field = { settings: { show_field: 1 } }
+                        }
+                        correctFieldList.push({
+                            field_id: fieldOnPipe.field_id,
+                            show: elementFromTable.show,
+                            width: elementFromTable.width ? elementFromTable.width : "150px"
+                        })
+                    }
+                    if (index + 1 == tableSettingsFieldListToView.length) {
+                        checkFiledFromPipe(correctFieldList)
+                    }
+
+                });
+            } else {
+                checkFiledFromPipe(tableSettingsFieldListToView);
+            }
+
+            function checkFiledFromPipe(correctFieldList) {
+                let counter = 0
+                fieldList.forEach((elemetFromPipe, index) => {
+                    let correctFiel = correctFieldList.find((elemet) => elemetFromPipe.field_id == elemet.field_id)
+                    if (!correctFiel) {
+                        self.gudhub.ghconstructor.getInstance(elemetFromPipe.data_type).then((data) => {
+                            let template = data.getTemplate();
+                            let show_field = template.model.data_model.interpretation.find((intrpr) => intrpr.src == 'table');
+                            if (!show_field) {
+                                show_field = { settings: { show_field: 1 } }
+                            }
+                            correctFieldList.push({
+                                field_id: elemetFromPipe.field_id,
+                                show: show_field.settings.show_field,
+                            });
+
+                            if (counter == fieldList.length - 1) {
+                                resolve(correctFieldList);
+                            }
+                            counter++
+                        }, function errorCallback(result) {
+                            counter++
+                        })
+                    } else {
+                        if (counter == fieldList.length - 1) {
+                            resolve(correctFieldList);
+                        }
+                        counter++
+                    }
+                });
+            }
+        });
+    }
+
+    createFieldsListToViewWithDataType(appId, tableSettingsFieldListToView) {
+        return new Promise(async (resolve) => {
+            let columnsToView = [];
+            let fieldList = await this.gudhub.getFieldModels(appId);
+
+            let actualFieldIds = fieldList.map((field) => +field.field_id);
+
+            columnsToView = fieldList.reduce((viewColumsList, currentField) => {
+                let field = viewColumsList.find((view, index) => {
+                    if (currentField.field_id == view.field_id) {
+                        return true;
+                    }
+                    return false;
+                });
+
+                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
+                        });
+                    })
+                }
+
+                return viewColumsList;
+            }, tableSettingsFieldListToView).filter((field) => actualFieldIds.indexOf(field.field_id) != -1);
+
+            resolve(columnsToView);
+        })
+    }
+}

package/GUDHUB/Utils/MergeFields/MergeFields.test.js

@@ -0,0 +1,38 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+import table_field_list from './mocks/table_field_list.js';
+import table_fields_to_view from './mocks/table_fields_to_view.js';
+
+import online_inventory_field_list from './mocks/online_inventory_field_list.js';
+import online_inventory_fields_to_view from './mocks/online_inventory_fields_to_view.js';
+
+import table_settings_field_list_to_view from './mocks/table_settings_field_list_to_view.js';
+
+describe("MERGE FIELDS", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    it("MERGE FIELDS LIST", async function () {
+        let fieldsToView = table_fields_to_view;
+        let fieldList = table_field_list;
+        let result = gudhub.util.mergeFieldLists(fieldsToView, fieldList);
+        result[0].field_id.should.equals(190);
+        result[1].data_model.interpretation.length.should.equals(1);
+
+        fieldsToView = online_inventory_fields_to_view;
+        fieldList = online_inventory_field_list;
+        result = gudhub.util.mergeFieldLists(fieldsToView, fieldList);
+        result[0].field_id.should.equals(192954);
+        result[2].data_model.interpretation.length.should.equals(6);
+    });
+
+    it("CREATES FIELDS LIST TO VIEW", async function () {
+        let tableSettingsFieldListToView = table_settings_field_list_to_view;
+        let appId = 16259;
+        let result = await gudhub.util.createFieldsListToView(appId, tableSettingsFieldListToView);
+        result.length.should.equals(12);
+        result[1].field_id.should.equals(254055);
+    });
+
+});